Detecting API backward compatibility between software versions

Abstract

To provide an operation for detecting the API compatibility between software versions.SOLUTION: The operation may include receiving an input related to a software application. The operation may further include determining first information. The operation may furthermore include extracting a set of data from a source of at least one web base on the basis of the determined first information. The operation may further include conducting a set of operations including at least one pattern search operation for the extracted set of data and generating a compatibility result. The operation may also include controlling a display device on the basis of the generated compatibility result. The display device is formed to display support information as a notification of the compatibility of at least one API or function used in the source code of the software application for the second version of the software.SELECTED DRAWING: Figure 18

Description

Technical Field

[0001] Embodiments discussed in this disclosure relate to detecting backward compatibility of application programming interfaces (APIs) between software versions.

Background Art

[0002] In software development, version management is an important technique that helps track changes to software source code. Typically, developers or organizations issue documentation that details changes introduced into the source code of a new version of software as compared to previous versions of the software. Software can be updated to a new version to add new functions, replace or delete existing functions, or fix bugs / exceptions that occurred in older versions of the source code. Typically, software can include methods or functions that a user can use in their application's source code. For example, software can expose methods that can be called by executing application programming interface (API) call code included in the application's source code. In the release of a new version, the software can include changes to the source code. For example, a method exposed in an older version of the software can be changed in the new version. In some cases, such changes can result in a break in the backward compatibility of the software. An application that calls such a method may not function properly. In some cases, the application may encounter an error or crash.

[0003] The subject matter of the claims in this disclosure is not limited to embodiments that solve any disadvantages or operate only in the environments as described above. Rather, this background art is provided only to illustrate one exemplary technique in which some of the embodiments described herein can be implemented.

Summary of the Invention

[0004] According to one embodiment, the operation may include receiving input related to a software application. The operation may further include determining, based on the input, one or more application programming interfaces (APIs) or functions that may be used in the source code of the software application, and first information about a first version of the software that provides one or more APIs or functions. The operation may further include extracting a set of data from one or more web-based sources based on the determined first information. The extracted set of data may include one or more changes in the source code of a second version of the software. The second version of the software may differ from the first version of the software. The extracted set of data may further include second information about one or more changes in the second version. The operation may further include performing a set of operations, including pattern lookup operations, on the extracted set of data to generate backward compatibility results. The operation may further include controlling a display device to display support information that informs about the compatibility of one or more APIs or functions used in the source code of the software application with respect to a second version of the software. The display device may be controlled based on the generated backward compatibility results.

[0005] The objectives and advantages of this embodiment are realized and achieved by at least the elements, features, and combinations specifically indicated in the claims.

[0006] Both the general description above and the embodiments for carrying out the invention described below are merely illustrative and descriptive, and do not limit the invention as described in the claims. [Brief explanation of the drawing]

[0007] Exemplary embodiments are described and illustrated with additional specificity and detail through the use of the accompanying drawings.

[0008] [Figure 1] This diagram illustrates an exemplary environment for detecting backward compatibility of APIs between software versions.

[0009] [Figure 2] This is a block diagram of a system for detecting backward compatibility of APIs between software versions.

[0010] [Figure 3] This document provides an example electronic user interface (UI) for providing input for detecting backward compatibility of APIs between software versions.

[0011] [Figure 4] A flowchart illustrating an exemplary method for generating a first database that stores software metadata and API metadata related to a collection of software is provided.

[0012] [Figure 5] This document provides a flowchart illustrating an exemplary method for determining one or more APIs used in a software application from the source code of that software application.

[0013] [Figure 6] This document provides a flowchart illustrating an exemplary method for extracting the contents of changelog and readme files related to software.

[0014] [Figure 7] A flowchart illustrating an example method for extracting the contents of a changelog is provided.

[0015] [Figure 8] A flowchart illustrating an exemplary method for generating compatibility results is provided.

[0016] [Figure 9] Illustrate a flowchart of an exemplary method for extracting a set of first messages related to one or more versions of software.

[0017] [Figure 10] Illustrate a flowchart of an exemplary method for generating compatibility results based on messages related to software versions.

[0018] [Figure 11] Illustrate a flowchart of an exemplary method for extracting a file containing the source code of a second version of software.

[0019] [Figure 12] Illustrate a flowchart of an exemplary method for generating compatibility results based on one or more collected code chunks.

[0020] [Figure 13] Illustrate a flowchart of an exemplary method for detecting function definitions.

[0021] [Figure 14] Illustrate a flowchart of an exemplary method for determining a first change in the function definitions of one or more functions.

[0022] [Figure 15] Illustrate a flowchart of an exemplary method for determining a second change in a set of input parameters of one or more functions.

[0023] [Figure 16] Illustrate a flowchart of an exemplary method for determining a third change in one or more output parameters of a function.

[0024] [Figure 17]An example of an electronic user interface (UI) for displaying support information on a display device is provided.

[0025] [Figure 18] A flowchart illustrating an exemplary method for detecting API compatibility between software versions is provided.

[0026] All of these are based on at least one embodiment described in this disclosure. [Modes for carrying out the invention]

[0027] Open Source Software (OSS) is becoming increasingly important in today's industry. Web-based repository hosting systems such as GitHub® have large communities of developers and organizations dedicated to building and sharing open source software. This open source software is used by various client applications with the help of APIs that enable interaction between client applications and the open source software. Thanks to a vast number of developers and organizations, this open source software is frequently updated. However, after OSS updates, APIs may not function as required, or may not function at all. This can result in one or more functions in a client application becoming unavailable, or even causing the client application to crash.

[0028] With the rapid increase in the number of updates to OSS, OSS can offer more functionality that can be consumed via application programming interfaces (APIs) and further integrated into client applications. Furthermore, these updates to OSS may fix several issues in previous versions of the OSS. Therefore, clients may want to update the version of OSS used by their client applications to improve security and / or the functionality of their client applications.

[0029] Clients may want to know if an API (or the upgraded OSS) is backward compatible before upgrading OSS. Generally, backward compatibility refers to a hardware or software system that can successfully interface with and use data from previous versions of the system or from other systems. An API may be said to be backward compatible if a client application (a program written to consume the API) that works with one version of the API can work in the same way with a future version of the API. In other words, an API is backward compatible between releases if a client can handle a new version of the API seamlessly (i.e., without any modifications to the client application's source code).

[0030] Traditional approaches to detecting backward compatibility may involve comparing two versions of the software's source code and then further detecting backward compatibility based on that comparison. This approach can be considered static because it does not take into account the dynamic behavior of the source code that most source code exhibits. Furthermore, this approach uses only one judgment marker related to the code to check for backward compatibility. In some scenarios, details of some important changes (such as changes to environment variables or secret keys) may not be reflected in the code but written to some other files (particularly text files) related to the upgraded software. Therefore, this approach may give a false judgment. Because this approach only relates to two different versions of the code, it may only cover a small fraction of all possible backward compatibility issues.

[0031] Other approaches to checking backward compatibility are specific to different categories of software. Each approach is applicable to only one category of software (such as a database schema). Because these approaches are category-dependent, a generalized approach is needed that can detect backward compatibility for all software, regardless of category.

[0032] Some embodiments described in this disclosure relate to methods and non-temporary computer-readable media for detecting backward compatibility of APIs between software versions. The disclosure system can check compatibility for each piece of software and is not limited to a specific category. Furthermore, the disclosure system may use at least two decision parameters to check whether an API (or OSS) is backward compatible. The first decision parameter may relate to the source code in both versions of the software, and the second decision parameter may relate to textual descriptions that may be written by the programmer about updates in the updated version of the software. Thus, the disclosure system can check backward compatibility based on two or more decision parameters, unlike conventional approaches that use only one decision parameter. Also, the disclosure system may define comprehensive rules and procedures so that most possible backward compatibility issues are covered, compared to previous approaches that may only be able to detect a fraction of all possible backward compatibility issues.

[0033] Embodiments of this disclosure will be described with reference to the accompanying drawings.

[0034] Figure 1 is a diagram illustrating an exemplary environment for detecting backward compatibility of APIs between software versions arranged according to at least one embodiment of the present disclosure. Referring to Figure 1, an exemplary environment 100 is shown. The exemplary environment 100 shows a system 102 and one or more web-based sources 104. One or more web-based sources 104 may host a collection of software or store data related to a collection of software. Furthermore, a display device 106, a communication network 108, and an electronic user interface (UI) 110 rendered on the display screen of the display device 106 are shown. The system 102, one or more web-based sources 104, and the display device 106 may be communicatively coupled to one another via the communication network 108.

[0035] Furthermore, a user 112 that may be associated with the display device 106 is shown. The display device 106 may include preferred logic, circuitry, and interfaces configured to receive input from the user 112 and display support information on an electronic UI 110. In one embodiment, the display device 106 may be a touch screen that allows the user 112 to provide one or more inputs via an electronic UI 110 rendered on the display device 106. The touch screen may be at least one of a resistive touchscreen, a capacitive touchscreen, or a thermal touchscreen. The display device 106 may be implemented through, but is not limited to, several known technologies, such as at least one of an LCD (Liquid Crystal Display) display, an LED (Light Emitting Diode) display, a plasma display, and / or organic LED (OLED) display technology, and / or other display devices. In one embodiment, the display device 106 may refer to a display screen of a head-mounted display (HMD), a smart glasses device, a see-through display, a projection-based display, an electrochromic display, or a transparent display.

[0036] In one embodiment, the display device 106 may correspond to a user device associated with user 112. User 112 may interact with system 102 via the user device. Examples of user device 106 may include, but are not limited to, a mobile device, a desktop computer, a laptop, a computer workstation, a server such as a cloud server, or a group of servers. In one or more embodiments, the user device may include a user terminal device and a server communicatively coupled to the user terminal device. Examples of user terminal devices may include, but are not limited to, a mobile device, a desktop computer, a laptop, or a computer workstation.

[0037] One or more web-based sources 104 may include appropriate logic, circuitry, and interfaces that can be configured to store information related to the collection of software. Each piece of software in the collection may be used for application development. Specifically, the software may expose or provide one or more APIs. Users 112 may have to include API call code or methods of the APIs in the source code of their software applications. Each piece of software in the collection may be OSS, FOSS (Free and Open Source Software), FLOSS (Free / Libre and Open Source Software), or proprietary software. Examples of one or more web-based sources 104 may include, but are not limited to, web-based code hosting servers, database servers, file servers, web servers, RSS (Really Simple Syndication) feeds, and servers hosting websites and web applications.

[0038] In one embodiment, one or more web-based sources 104 may be implemented as servers, and the servers may include storage distributed across one or more availability zones (e.g., data centers). In another embodiment, each data source may include a front-end system and a back-end system. The front-end system may be configured to provide an interface for displaying information related to the software (e.g., a web page or a client-side interface for a web application). The back-end system may store databases, logic, and instructions for processing requests from the front-end system to access information related to the software.

[0039] In one embodiment, one or more web-based sources 104 may host software (or a collection of software) and enable individuals and / or organizations to manage the software via a web-based interface. In another embodiment, a web-based source may be a software hosting system that includes web pages on the software. The web pages may include the source code of the software (if the software is open source), as well as links to other software-related files such as documentation, change logs, readme files with descriptions of the corresponding software, test results, API reference guides, and other additional links or references. Users (including user 112) may access the collection of software via API calls, web clients (e.g., web browsers), or command-line interfaces.

[0040] User 112 may be a developer (or group of developers) of a software application. The software application may use one or more APIs or functions in its source code. For example, the source code may include API call code or function code that corresponds to a specific operation or task of the software application. Such APIs or functions may be provided by a first version of the software that may be hosted on one or more web-based sources 104.

[0041] Software that provides one or more APIs or functions can be updated from the first version to a second version at any time. The second version of the software may include changes to the source code of the first version of the software. For example, changes may include modifications to function / method definitions, modifications to the number and types of I / O parameters of functions, deprecation of existing functions, and addition of new API methods or functions. In some cases, the second version may include syntax changes that may be introduced when the first version is upgraded to support a newer version of the programming language. Some of the changes may be fixes introduced in the second version of the software to remove bugs that exist in the first version of the software.

[0042] Such changes may cause parts of the software application's source code to cause errors during execution. These parts of the source code may include references to or calls to APIs or functions provided by the first version of the software. If parts of the APIs or functions from the first version of the software are not backward compatible with the second version of the software, errors may occur. User 112 may want to avoid backward compatibility issues. Therefore, the source core (or at least parts of the source code) may need to be checked for backward compatibility and updated with changes to make the software application's source code compatible with the second version of the software.

[0043] Before updating, it may be checked whether the second version of the software is backward compatible with the first version. If the second version is not backward compatible, the source code or a portion of the source code of the software application may need to be modified. If the second version is backward compatible, the software application may not encounter any errors during execution as a result of the backward compatibility. In such cases, modifications to the software application may not be necessary.

[0044] A set of actions may be performed, as described herein, to detect whether a second version of the software is backward compatible. System 102 may be configured to receive input related to a software application. The software application may be a user application developed or managed by user 112. For example, the software application may be developed by user 112 via a low-code, no-code, or code-based application development platform. The received input may include, for example, the source code of the software application, or a portion of the source code that may be associated with one or more APIs or functions (which may be used in the source code of the software application). In some cases, the received input may include text information. The text information may include first data related to one or more APIs or functions, second data related to the name of the software that provides the one or more APIs or functions, and third data related to the first version of the software. For example, the text information may include Apache POI as the name of the API, Apache as the software that provides the Apache POI API, and 5.0 as the version of the Apache POI API.

[0045] System 102 may be configured to determine first information about one or more APIs or functions that may be used in the source code of a software application. Additionally, the determined first information may relate to a first version of the software that provides the one or more APIs or functions. The first information may be determined based on received input. Further details regarding determining one or more APIs or functions from the source code of a software application are provided, for example, in Figure 5.

[0046] System 102 may further be configured to extract a set of data from one or more web-based sources 104 based on the determined first information. The extracted set of data may include one or more changes in the source code of a second version of the software compared to the source code of a first version of the software. The second version of the software may differ from the first version of the software. For example, the second version may be an upgrade to the first version of the software. In one embodiment, the extracted set of data may include a first file containing the source code of the second version of the software, a second file containing second information about one or more changes in the source code of the second version, a third file containing a description of the software, and a set of first messages relating to one or more changes introduced in the source code of the second version of the software.

[0047] System 102 may also be configured to perform a set of operations on the extracted data set to generate compatibility results. The set of operations may include pattern search operations, such as string search operations (using regular expressions (regex)). Details about the set of operations and pattern search operations are provided, for example, in Figures 8, 10, 12, 13, 14, 15, and 16.

[0048] System 102 may be further configured to control display device 106 based on the generated compatibility results. Display device 106 may be controlled to display support information that can inform about the compatibility of one or more APIs or functions used in the first source code with respect to a second version of the software. If the second version of the software is a newer or later version of the software compared to the first version, such API or function compatibility may be called backward compatibility. Alternatively, if the second version of the software is an older version of the software compared to the first version, such API or function compatibility may be called forward compatibility.

[0049] Communication between system 102, one or more web-based sources 104, and display device 106 may be carried out via a communication network 108. The communication network 108 may include a communication medium from which system 102 can communicate with one or more web-based sources 104, display device 106, and / or other devices (not shown). Examples of the communication network 108 may include, but are not limited to, the internet, cloud networks, cellular networks (such as 4th generation LTE (Long-Term Evolution) or 5th generation NR (New Radio)), Wi-Fi (Wireless Fidelity) networks, PAN (Personal Area Network), LAN (Local Area Network), and / or MAN (Metropolitan Area Network). Various devices in the exemplary environment 100 may be configured to connect to the communication network 108 according to various wired and wireless communication protocols. Examples of such wired and wireless communication protocols may include, but are not limited to, at least one of the following: TCP / IP (Transmission Control Protocol and Internet Protocol), UDP (User Datagram Protocol), HTTP (Hypertext Transfer Protocol), FTP (File Transfer Protocol), ZigBee, EDGE, IEEE 802.11, Li-Fi (light fidelity), 802.16, IEEE 802.11s, IEEE 802.11g, multi-hop communication, wireless access point (AP), device-to-device communication, cellular communication protocols, and / or Bluetooth (BT) communication protocols, or any combination thereof.

[0050] System 102 may be modified, added to, or omitted without departing from the scope of this disclosure. For example, in some embodiments, System 102 may include any number of other components that are not expressly exemplified or described.

[0051] Figure 2 is a block diagram of a system for detecting backward compatibility of APIs between software versions arranged according to at least one embodiment described in this disclosure. Figure 2 is described in conjunction with the elements from Figure 1. Referring to Figure 2, a block diagram 200 of system 102 of Figure 1 is shown. Computing system 102 may include a processor 202, memory 204, and persistent data storage 206. In some embodiments, system 102 may also include input / output (I / O) devices 208, which may include a network interface 210 and a display device 104. Furthermore, one or more web-based sources 104 that may be communicatively coupled to system 102 are shown.

[0052] Processor 202 may include suitable logic, circuitry, and / or interfaces that can be configured to execute program instructions associated with different operations to be performed by System 102. Processor 202 may include any suitable special-purpose or general-purpose computer, computing entity, or processing device, including various computer hardware or software modules, and may be configured to execute instructions stored in any applicable computer-readable storage medium. For example, Processor 202 may include a microprocessor, microcontroller, digital signal processor (DSP), application-specific integrated circuit (ASIC), field-programmable gate array (FPGA), or any other digital or analog circuitry configured to interpret and / or execute program instructions and / or process data. Although illustrated as a single processor in Figure 2, Processor 202 may include any number of processors configured to individually or collectively perform or direct any number of operations of System 102, as described in this disclosure.

[0053] In some embodiments, the processor 202 may be configured to interpret and / or execute program instructions stored in memory 204 and / or persistent data storage 206, and / or process data. In some embodiments, the processor 202 may fetch program instructions from persistent data storage 206 and load them into memory 204. After the program instructions are loaded into memory 204, the processor 202 may execute the program instructions. Some examples of the processor 202 may be a central processing unit (CPU), a reduced instruction set computer (RISC) processor, an ASIC processor, a composite instruction set computer (CISC) processor, a graphics processing unit (GPU), a coprocessor, and / or a combination thereof.

[0054] Memory 204 may include preferred logic, circuitry, and / or interfaces that can be configured to store program instructions executable by the processor 202. In certain embodiments, memory 204 may be configured to store received inputs, determined first information relating to one or more APIs or functions, and a first version of software. In certain embodiments, memory 204 may be configured to store a set of extracted data, second information. Memory 204 may include a computer-readable storage medium for carrying or having computer-executable instructions or data structures stored therein. Such a computer-readable storage medium may include any available medium that can be accessed by a general-purpose or dedicated computer such as the processor 202.

[0055] For example, but not limited to, such computer-readable storage media may include tangible or non-temporary computer-readable storage media, including random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), compact disk read-only memory (CD-ROM), or other optical disk storage, magnetic disk storage, or other magnetic storage, flash memory devices (e.g., solid-state memory devices), or any other storage media that may be used to carry or store specific program code in the form of computer-executable instructions or data structures and that can be accessed by a general-purpose or special-purpose computer. Combinations of the above may also fall within the scope of computer-readable storage media. Computer-executable instructions may include, for example, instructions and data configured to cause a processor 202 to perform a specific operation or group of operations associated with system 102.

[0056] The persistent data storage 206 may include preferred logic, circuitry, and / or interfaces that can be configured to store program instructions executable by the processor 202. In one embodiment, the persistent data storage 206 may be configured to store a first file, a second file, a third file, and a set of messages. In some other embodiments, the persistent data storage 206 may be configured to store one or more tags related to compatibility. The persistent data storage 206 may include a computer-readable storage medium for carrying or having computer-executable instructions or data structures stored therein. Such a computer-readable storage medium may include any available medium that can be accessed by a general-purpose or dedicated computer such as the processor 202.

[0057] For example, and not limited to, such computer-readable storage media may include tangible or non-temporary computer-readable storage media that are optical disk storage, magnetic disk storage, or other magnetic storage devices (e.g., HDDs (Hard-Disk Drives)), flash memory devices (e.g., SSDs (Solid State Drives), SD (Secure Digital) cards, or other solid-state memory devices), or any other storage media that are used to carry or store specific program code in the form of computer-executable instructions or data structures and that can be accessed by a general-purpose or special-purpose computer. Combinations of the above may also be included within the scope of computer-readable storage media. Computer-executable instructions may include, for example, instructions and data configured to cause a processor 202 to perform a specific operation or group of operations associated with system 102.

[0058] I / O device 208 may include preferred logic, circuitry, interfaces, and / or code that can be configured to receive one or more inputs. I / O device 208 may be further configured to provide outputs in response to one or more inputs. I / O device 208 may include various I / O devices that can be configured to communicate with other components such as processor 202 and network interface 210. Examples of input devices may include, but are not limited to, a touchscreen, keyboard, mouse, joystick, and / or microphone. Examples of output devices may include, but are not limited to, display device 106 and speaker.

[0059] The network interface 210 may include preferred logic, circuitry, interfaces, and / or code that can be configured to establish communication between system 102, one or more web-based data sources 104, and display devices 106 via a communication network 108. The network interface 210 may be implemented by the use of various known techniques to support wired or wireless communication of system 102 via a communication network 116. The network interface 210 may include, but is not limited to, an antenna, a radio frequency (RF) transceiver, one or more amplifiers, a tuner, one or more oscillators, a digital signal processor, a codeder-decoder (CODEC) chipset, a subscriber identification module (SIM) card, and / or a local buffer.

[0060] The network interface 210 can communicate wirelessly with wireless networks such as the Internet, intranets, and / or cellular telephone networks, wireless local area networks (LANs), and / or metropolitan area networks (MANs). Wireless communication may use any of several communication standards, protocols, and technologies, such as GSM (Global System for Mobile Communications), EDGE (Enhanced Data GSM Environment), W-CDMA (wideband code division multiple access), LTE (Long Term Evolution), CDMA (code division multiple access), TDMA (time division multiple access), Bluetooth, Wi-Fi (Wireless Fidelity) (IEEE 802.11a, IEEE 802.11b, IEEE 802.11g, and / or IEEE 802.11n, etc.), VoIP, Li-Fi (light fidelity), or Wi-MAX.

[0061] As shown in Figure 1, functions or operations performed by system 102 may be performed by processor 202. Operations performed by processor 202 are described in detail, for example, in Figures 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, and 18.

[0062] Figure 3 illustrates an exemplary electronic user interface (UI) for providing input for detecting backward compatibility of APIs between software versions, according to at least one embodiment described in this disclosure. Figure 3 is described in conjunction with the elements of Figures 1 and 2. Referring to Figure 3, an electronic UI 300 is shown, which may be an exemplary implementation of the electronic UI 110 of Figure 1. The electronic UI 300 may be displayed on the display device 106 based on user requests that may be received via an application interface displayed on the display screen of the display device 106. The application interface may be part of application software, such as a software development kit (SDK), a cloud server-based application, a web-based application, an OS-based application / application suite, an enterprise application, or a mobile application.

[0063] Furthermore, as discussed, in Figure 1, the received input may relate to a software application that uses one or more APIs or functions provided by the software. The received input may include at least one of the following: the source code of the software application, a portion of the source code that may relate to one or more APIs or functions, or text information.

[0064] The electronic UI 300 displays a set of UI elements, such as a first UI element 302, a second UI element 304, and a third UI element 306. The first UI element 302 may be labeled, for example, "Upload Source Code". The first UI element 302 may include a browse button 302A. Through the browse button 302A, the user 112 may upload a file containing the source code of a software application or a portion of the source code that may be associated with one or more APIs or functions. The source code of the software application may be written in any programming language and may include information about one or more APIs or functions and a first version of the software that provides one or more APIs or functions.

[0065] In some other embodiments, user 112 may not wish to upload the source code or a portion of the source code of the software application. In such scenarios, user 112 may provide input via a second UI element 304. The second UI element 304 may be labeled, for example, “Enter Details”. The second UI element may include an API text box 304A, a software information text box 304B, and / or an updated software information text box 304C. Through the API text box 304A, the software information text box 304B, and / or the updated software information text box 304C, the system 102 may receive text information related to the software application. The text information may include first data related to one or more APIs or functions, second data related to the name of the software that provides one or more APIs or functions, and third data related to a first version of the software.

[0066] The API text box 304A may be a text box, and user 112 may add information about the names of one or more APIs or functions that may be used in the first source code of the software application. Through the API text box 304A, system 102 may receive first data of text information that may be associated with one or more APIs or functions.

[0067] The software information text box 304B may allow user 112 to add information about software that provides one or more APIs or functions to a software application. Specifically, the information about the software may include at least the name of the software and the current version of the software (i.e., the first version). Through the software information text box 304B, system 102 may receive second and third data of text information. As discussed above, the second data may relate to the name of the software that provides one or more APIs or functions. The third data may relate to the first version of the software.

[0068] The updated software information text box 304C may allow user 112 to add information about an updated version (or second version) of the software, for which compatibility of one or more APIs or functions may need to be determined. Note that the updated software information text box 304C may be optional. By default, system 102 may be configured to select the latest or most recent stable version of the software as the second version of the software.

[0069] The third UI element 306 may be labeled as “Submit” and may be a button. By selecting the button, the system 102 may detect the compatibility of one or more APIs or functions used in the first source code with respect to the second version of the software.

[0070] It should be noted that the UI / UI elements within the electronic UI 300 are provided merely as examples and should not be construed as limiting this disclosure. In some embodiments, the electronic UI 300 may be suitably modified to allow the user 112 to input or upload more information related to the software and / or software application.

[0071] Figure 4 illustrates a flowchart of an exemplary method for generating a first database for storing software metadata and API metadata related to a collection of software, according to at least one embodiment described in this disclosure. Figure 4 is described in conjunction with the elements of Figures 1, 2 and 3. Referring to Figure 4, flowchart 400 is shown. The method shown in flowchart 400 may begin from 402 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0072] In 402, a connection to one or more web-based sources 104 may be established. The processor 202 may be configured to establish a connection to one or more web-based sources 104. One or more web-based sources 104 may include one or more web-based software hosting sources (e.g., GitHub®), one or more version control systems, one or more web-based software metadata storage services, or one or more websites. The processor 202 may be configured to establish a connection between the system 102 and one or more web-based sources 104 via a communication network 108. One or more web-based sources 104 may host a collection of software (OSS, FOSS, FLOSS, or proprietary) that provides a collection of APIs or functions for the development of one or more software applications by users.

[0073] In 404, the name of each software in the software collection can be retrieved. The software collection may be hosted on one or more web-based sources 104. The name of each software in the software collection may be retrieved from one or more web-based sources 104 based on an established connection between system 102 and one or more web-based sources 104. In one embodiment, processor 202 may be configured to send a first API request to one or more web-based sources 104 to retrieve the name of each software in the collection. In one embodiment, the retrieved name of each software may be stored in a first data structure (e.g., a first list). For example, but not limited to, the software names may be "ABC", "BCD", and "CDE". In an embodiment, the retrieved names of the software may correspond to software metadata associated with the corresponding software.

[0074] In 406, one or more versions of each software in the software collection may be retrieved. One or more versions may include released and unreleased versions of the software that may be available in one or more web-based sources 104. Released versions of the software may be available to the general public, while one or more unreleased versions of the software may be in testing and may be available to a specific group of people.

[0075] In one embodiment, the processor 202 may be configured to send a second API request to one or more web-based sources 104 to retrieve one or more versions of the corresponding software. The retrieved versions of the software may be stored in a second data structure (e.g., a second list). In an embodiment, the second list may include the name of the software and one or more corresponding versions. The versions may be represented by numbers, letters, strings, or alphanumeric strings. In one embodiment, the retrieved name of the software, along with one or more corresponding versions of the software, may correspond to software metadata associated with the corresponding software.

[0076] In 408, software may be selected from a collection of software. Processor 202 may be configured to select software based on a list of one or more versions of each software (e.g., a second list). The selected software may correspond to the first entry in the first list. In one embodiment, processor 202 may be configured to select another software after control has been transferred back from 430 to 408. The new software may correspond to the next entry in the list. Referring to the first example, the name of the selected first software may be "ABC".

[0077] In 410, a version may be selected from one or more versions of the selected first software. The version may be selected from one or more versions associated with the selected software and stored in the second list.

[0078] In 412, the line count of the code in the source code of a selected version of the selected software can be obtained. The line count can be obtained from one or more web-based sources 104 via a third API request to one or more web-based sources 104. The code can be written in one or more programming languages ​​such as Java, C#, C++, Python, JavaScript, and C.

[0079] In 414, the percentage of code written in each programming language can be calculated. The percentage of code in a first programming language in a selected version of the selected software can be calculated based on the line count of code in the first programming language and the sum of the line counts of code in all programming languages ​​in the selected version.

[0080] In one embodiment, the processor 202 may be configured to store the percentage of code computed in each programming language in a third data structure (such as a third list). In another embodiment, the system 102 may be configured to receive the percentage of code computed in each programming language via a fourth API request to one or more web-based sources 104. Referring to the previous example, the computed percentages of code written in Java, C#, C++, Python, and JavaScript may be 45.6%, 16.6%, 11.3%, 5.7%, 7.2%, and 4.1%, respectively. In some embodiments, metadata associated with selected software may include the name of the selected software, one or more versions of the selected software, and information about the programming languages ​​used in one or more versions of each software. The system 102 may be configured to collect software metadata for each software in a determined collection of software from one or more web-based sources 104.

[0081] In 416, a programming language may be selected. The programming language may be selected based on the percentage of code written in each programming language for a selected version of the selected software.

[0082] In step 418, it may be determined whether the calculated percentage of the selected programming language is greater than a predefined threshold. The predefined threshold can be a pre-set value. If the calculated percentage of the selected first programming language is less than the predefined threshold, control may be transferred back to step 416, the selected programming language may be ignored, and API metadata related to the set of APIs written in the selected programming language may not be determined. If the calculated percentage of the selected first programming language is greater than the predefined threshold, control may be transferred to step 420. For example, if the predefined threshold is set to 15%, API metadata related to the set of APIs written in the Java and C# programming languages ​​may be determined.

[0083] In 420, a search query may be generated. The search query may be generated to search for a set of APIs written in a selected programming language within a selected version of the software. The search query may include the name of the selected software, the selected version of the software, the name of the selected programming language, and a keyword. The keyword may be "API documentation". For example, the generated search query may be "ABC 1.0 Java API Documentation", where ABC is the name of the software, 1.0 is the version of the software, Java is the selected programming language, and API documentation is the keyword.

[0084] In 422, the generated search query can be used to perform a search. The processor 202 can be configured to perform a search using the generated search query against one or more web-based sources 104.

[0085] In 424, information may be collected from the search results. The search results may provide API documentation for a selected version of the software. The API documentation may include the name of each API in the set of APIs and a description of each API. In some embodiments, the information collected from the search results may be stored as API metadata associated with the corresponding API.

[0086] At 426, it may be determined whether each programming language of the selected version of the selected software was selected at 416. If each programming language was selected at 416, control may be transferred at 428. Otherwise, control may be transferred repeatedly to 416 until each programming language is selected.

[0087] In 428, it may be determined whether one or more versions of the selected software were selected in 410. If each of the one or more versions of the selected first software is selected in 410, control may be transferred to 430. Otherwise, control may be transferred to 410 until each of the one or more versions of the selected software is selected in 410.

[0088] In 430, it may be determined whether each piece of software in the software collection has been selected in 408. If each piece of software in the software collection has been selected in 408, control may be transferred to 432. Otherwise, control may be transferred to 408.

[0089] In 432, a first database may be generated. The generated first database may contain data relating to each of the collections of software hosted on one or more web-based sources 104. Specifically, system 102 may store collected software metadata and collected API metadata in the first database. The collected software metadata may include at least one of the following: the name of the software, one or more versions of each software in the collection of software, and information about the programming languages ​​used in each of the one or more versions of each software. In one embodiment, system 102 may determine first information from the generated first database. The first information may relate to one or more APIs or functions used in the source code of a software application (i.e., a developer / user application), and a first version of the software that provides one or more APIs.

[0090] In another embodiment, for each piece of software in the software collection, the data stored in the first database may include the name of the software, one or more versions of the software, one or more programming languages ​​used in each version of the software (the calculated percentage of which is greater than a predefined threshold), and a set of APIs available in each version of the software in a particular programming language. As an example, but not an limitation, a first table of the generated first database is shown in Table 1 as follows: [Table 1]

[0091] Control may be passed to termination. Flowchart 400 is illustrated with individual operations such as 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, and 432, but in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without impairing the essence of the disclosed embodiments.

[0092] Figure 5 illustrates a flowchart of an exemplary method for determining one or more APIs used in a software application from the source code of the software application, according to at least one embodiment described herein. Figure 5 is described in conjunction with the elements of Figures 1, 2, 3, and 4. Referring to Figure 5, flowchart 500 is shown. The method shown in flowchart 500 may begin from 502 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0093] In 502, system 102 may be configured to read (or analyze) the source code of a software application contained in the received input. The source code of the software application may be read (or analyzed) in order to determine one or more definition files associated with the source code. In one embodiment, the determined one or more definition files may correspond to artifact files associated with the source code of the software application.

[0094] In 504, one or more definition files may be analyzed. System 102 may be configured to analyze one or more definition files related to the loaded source code. For example, artifact files may include dependencies, binary resources, use cases, a unified modeling language, software documentation, class diagrams, images, risk assessments, and prototypes related to the source code. In one embodiment, the artifact file may include the received source code of a software application. As an example, but not an limitation, the artifact file may include requirements.txt, pom.xml, or package.json files related to the source code.

[0095] In 506, software and associated version information can be determined. System 102 may be configured to determine software that can provide one or more APIs or functions (for use in a software application) based on an analysis of one or more definition files. For example, based on an analysis of definition files, system 102 may be configured to determine version information associated with the determined software. The version information may specify the current version (or first version) of the software used in the source code of the software application.

[0096] In 508, a first database may be queried. System 102 may be configured to query the first database (generated in 432) using the determined version information. The first database may be configured to determine first information about one or more APIs or functions that may be used in the source code of a software application. For example, such information may include the names of API methods, or functions that are called or can be invoked in the source code of a software application via API call codes or function definitions.

[0097] In 510, it may be determined whether the names of one or more APIs used in the source code of the software application exist in the first database. If the names of one or more APIs used in the source code of the software application do not exist in the first database, control may be transferred to 512. Otherwise, control may be transferred to 514.

[0098] In 512, system 102 may be configured to look up each of the sets of APIs stored in a first database in order to determine one or more APIs used in the source code of a software application. The lookup may be performed based on the names of the sets of APIs stored in the first database. System 102 may further determine first information about one or more APIs or functions used in the source code of a software application.

[0099] In 514, system 102 may be configured to look up each of the sets of APIs stored in a first database in order to determine one or more APIs used in the source code of a software application. The lookup may be performed based on the names of the sets of APIs stored in the first database, along with the parameter lists associated with the corresponding APIs. The parameter lists may be used to determine exactly one or more APIs used in the source code, since there may be many APIs with the same name but different parameters (method overloads and method overrides). System 102 may further determine first information about one or more APIs or functions used in the source code of a software application. Note that the steps in 510, 512, and 514 are optional and can be skipped.

[0100] Control may be passed to termination. Flowchart 500 is illustrated with individual operations such as 502, 504, 506, 508, 510, 512, and 514. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0101] Figure 6 illustrates a flowchart of an exemplary method for extracting the contents of changelog and readme files associated with software, according to at least one embodiment described in this disclosure. Figure 6 is described in conjunction with the elements of Figures 1, 2, 3, 4, and 5. Referring to Figure 6, flowchart 600 is shown. The method shown in flowchart 600 may begin from 602 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0102] In 602, system 102 may receive input related to a software application. The input may include the source code or a portion of the source code of the software application. In one embodiment, system 102 may receive the name of the software and a first version of the software that provides one or more APIs or functions for use in the source code of the software application. The input may further include the names of one or more APIs or functions.

[0103] In 604, system 102 may determine first information based on the received input. The first information may be about one or more APIs or functions used in the source code of a software application. Additionally, the first information may be about a first version of the software that provides one or more APIs or functions.

[0104] In 606, system 102 may extract a set of data related to a second version of the software from one or more web-based sources 104. The extraction may be performed based on the first information determined. The extracted set of data may include a first file containing the source code of the second version of the software, and / or a second file containing second information about one or more changes introduced in the second version compared to the first version of the software. The second file may correspond to a changelog containing a curated list of notable changes in chronological order for each version of the software.

[0105] In 608, system 102 may be configured to determine whether the extracted set of data includes a second file. If the extracted set of data includes a second file, control may be transferred to 610. Otherwise, control may be transferred to 612.

[0106] In 610, the contents of the second file may be stored in a second table of the first database. The contents of the second file may be second information about one or more changes introduced in the second version of the software compared to the first version of the software. Typically, the second file is written by a developer or contributor. The second file may indicate one or more changes that make one or more API methods or functions in the second version of the software incompatible with API methods or functions in the first version of the software.

[0107] In 612, system 102 may be configured to retrieve a third file related to the software (or a second version of the software). System 102 may retrieve the third file from one or more web-based sources 104. In some embodiments, the extracted data set may include a third file. The third file may include a description of the software. Specifically, the third file may correspond to a readme file related to the software (or a second version of the software). As an example, but not an limitation, the contents of the third file may include answers to the following questions: 1. What is this software used for? 2. Why is this software useful? 3. How to get started with the source code of this software 4. What links or resources are useful to users in implementing the source code of this software? 5. Who will maintain this repository and contribute to it? 6. What one or more changes will be implemented in the second version of the software? (Optional)

[0108] At 614, it may be determined whether the acquisition of the third file was successful. If the third file is acquired from one or more web-based sources 104 or a set of extracted data, the acquisition of the third file may be considered successful, and control may be transferred to 616. Otherwise, control may be transferred to 620.

[0109] In 616, it may be determined whether the third file contains the contents of the second file. System 102 may be configured to perform a pattern search operation to determine whether the contents of the second file are present in the third file. Specifically, the pattern search operation may correspond to a string search operation that can use a regular expression (regex) to find one or more tags related to compatibility in the extracted set of data. For example, if one or more first tags correspond to "changelog", "release notes", "change", or "change log", the regular expression would be "

number

[0110] In 618, system 102 may be configured to extract the contents of a second file from a third file 620. The contents of the second file may be associated with one or more detected tags. System 102 may be configured to extract the contents associated with one or more tags and store the extracted contents in a second table of the first database.

[0111] In 620, system 102 may be configured to retrieve one or more archives of software. System 102 may retrieve one or more archives of software from one or more web-based sources 104. In one embodiment, one or more archives of software may be retrieved using a second search query. In another embodiment, system 102 may be configured to implement a web crawler to retrieve one or more archives of software from one or more web-based sources 104.

[0112] Each of the one or more archives obtained may contain multiple files related to the software. Specifically, such an archive of the software may correspond to a history record of the software on one or more web sources 114. The history record may include a first file (the source code of the software), a second file (i.e., a changelog for the software), a third file (i.e., a readme file for the software), and / or a first set of messages related to the software (i.e., commit messages).

[0113] In 622, it may be determined whether or not one or more archives of the software have been successfully retrieved. One or more archives of the software may correspond to the corresponding software history records that reside on one or more web-based sources 114. The history records may include a first file (such as source code), a second file (such as a changelog), a third file (such as a readme), and / or a first set of messages associated with the corresponding version of the software (such as a pull request message). If one or more archives have been successfully retrieved, control may be transferred to 624. Otherwise, if one or more archives of the software do not reside on one or more web-based sources 104, control may be transferred to 628.

[0114] In 624, it may be determined whether one or more archives of the software contain the contents of the second file. If one or more archives of the software contain the contents of the second file, control may be transferred to 626. Otherwise, the contents of the second file may be considered not to exist in any of the retrieved archives of the software, and control may be transferred to 628.

[0115] In 626, system 102 may be configured to extract the contents of a second file from one or more archives. Details regarding the extraction of a second file from one or more archives of software or the contents of a second file are provided, for example, in Figure 7.

[0116] At 628, control may be passed to termination. In some embodiments, the system 102 may be configured to repeat operations 604-626 for each version of one or more versions of the software, and if content exists in the second file, store its contents in the first table of the database.

[0117] Control may be passed to termination. Flowchart 600 is illustrated with individual operations such as 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 426, and 628, but in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0118] Figure 7 illustrates a flowchart of an exemplary method for extracting changelog content according to at least one embodiment described in this disclosure. Figure 7 is described in conjunction with the elements of Figures 1, 2, 3, 4, 5, and 6. Referring to Figure 7, flowchart 700 is shown. The method shown in flowchart 700 may begin from 702 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0119] In 702, system 102 may be configured to retrieve one or more archives of software. System 102 may retrieve one or more archives of software from one or more web-based sources 104. In one or more embodiments, one or more archives of software may be retrieved using a second search query. Specifically, system 102 may be configured to search one or more web-based sources 104 using a second search query. System 102 may then analyze one or more search results obtained based on the search to retrieve one or more archives of software.

[0120] In 704, system 102 may be configured to select a software archive from one or more archives of acquired software. In an embodiment, each of the set of archives may be sorted based on the archive date associated with the corresponding archive. The sorted one or more archives may be stored in a data structure (such as a list). The archive date may be associated with the date the software was archived. The selected archive may be at the top of the data structure storing the sorted archives. In one embodiment, system 102 may be further configured to decompress the selected archive (if necessary).

[0121] In some embodiments, control may be transitioned back from 720 to 704. In such scenarios, system 102 may select the next software archive from the list in a sequential manner.

[0122] In 706, it may be determined whether the second file exists within the selected first archive. If the second file exists within the selected archive (or the unzipped archive), control may be transferred to 708. Otherwise, control may be transferred to 712.

[0123] In 708, system 102 may be configured to extract a second file from a selected archive or an unzipped and selected archive. The second file may have a unique name. System 102 may extract the second file by analyzing the name of each file. In one embodiment, system 102 uses a regular expression to search for the second file from multiple files. For example, a regular expression to search for the second file might be:

number

[0124] In 710, the contents of the second file may be stored in a second table of the first database. The contents of the second file may include second information about one or more changes to the first archive version of the software relative to the first version of the software.

[0125] In 712, system 102 may be configured to obtain a third file associated with the selected software archive. In some embodiments, system 102 may extract the third file from the unzipped and selected archive or from multiple files within the selected archive.

[0126] At 714, it may be determined whether the retrieval of the third file was successful. If the third file is obtained from multiple files, the search for the third file may be considered successful, and control may be transferred to 716. Otherwise, control may be transferred to 720.

[0127] In step 716, it may be determined whether the third file contains the contents of the second file. Details regarding the determination of the presence of the contents of the second file in the retrieved third file are provided, for example, in Figure 6. If the contents of the second file are present in the third file, control may be transferred to step 718. Otherwise, control may be transferred to step 720.

[0128] In 718, system 102 may be configured to extract the contents of the second file from the third file 620. System 102 may also be configured to store the extracted contents of the second file in a second table of the first database, as discussed in 710.

[0129] At 720, it may be determined whether each of the one or more archives has been processed. Processing an archive may correspond to the execution of operations 706 through 718. If each archive has been processed, control is passed to 722. Otherwise, control may be transferred back to 704.

[0130] In 722, control may be passed to termination.

[0131] Control may be passed to termination. Although flowchart 700 is illustrated with individual operations such as 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, and 722, in particular embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without impairing the essence of the disclosed embodiments.

[0132] Figure 8 illustrates a flowchart of an exemplary method for generating compatibility results according to at least one embodiment described in this disclosure. Figure 8 is described in conjunction with the elements of Figures 1, 2, 3, 4, 5, 6, and 7. Referring to Figure 8, flowchart 800 is shown. The method shown in flowchart 800 may begin from 802 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0133] In 802, system 102 may be configured to perform a first pattern search operation from a set of operations on the extracted set of data (e.g., extracted in Figure 6). Specifically, system 102 may be configured to perform the first pattern search operation on the contents of a second file (i.e., the changelog present in the extracted set of data) to detect one or more tags related to compatibility. The first pattern search operation may be a string search operation that can detect one or more tags related to compatibility using one or more regular expressions. For example, but not limited to, one or more tags may include "breaking", "break", "incompatible", "breaking change", etc.

[0134] In 804, it may be determined whether one or more tags were found in the contents of the second file. If one or more tags were found in the contents of the second file, control may be transferred to 806. Otherwise, control may be transferred to 810.

[0135] In 806, system 102 may be configured to extract one or more sentences associated with one or more detected tags. The one or more detected sentences may include one or more detected tags.

[0136] In 808, system 102 may be configured to determine a first set of API names or function names mentioned in one or more extracted sentences. Along with one or more detected tags, a first set of API names or function names may be mentioned in one or more extracted sentences.

[0137] In 810, system 102 may be configured to extract one or more sentences related to one or more keywords. One or more keywords may be semantically similar to one or more tags. For example, one or more keywords may be "compatible", "breaking", "break", "incompatible", "breaking change", etc. System 102 may be configured to perform a pattern search operation to detect one or more keywords in the contents of a second file. One or more detected sentences may contain the one or more detected keywords.

[0138] In 812, system 102 may be configured to determine a second set of API names or function names mentioned in one or more extracted sentences. Each of the one or more sentences may contain one or more keywords and at least one API name from the second set of API names.

[0139] In 814, compatibility results may be generated. To generate compatibility results, system 102 may be configured to determine whether a first set of determined API names or function names and / or a second set of determined API names or function names contain the names of one or more APIs or functions used in the source code of a software application. The compatibility results may be generated based on the determination that the first set of determined API names or function names and / or a second set of determined API names or function names contain the names of APIs or functions used in the source code of a software application.

[0140] For example, if the determined tags and keywords (e.g., incompatible, broken, etc.) indicate incompatible behavior that will break, and the determined API name or function name includes the name of an API or function used in the source code of the software application, the compatibility result may indicate that the API or function used in the source code of the software application is incompatible with a second version of the software. If the determined tags and keywords (e.g., compatible, consistent, etc.) indicate that compatibility is still maintained, and the determined API name or function name includes the name of an API or function used in the source code of the software application, the compatibility result may indicate that the API or function used in the source code of the software application is compatible with a second version of the software.

[0141] Control may be passed to termination. Flowchart 800 is illustrated with individual operations such as 802, 804, 806, 808, 810, 812, and 814. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0142] Figure 9 illustrates a flowchart of an exemplary method for extracting a first set of messages related to one or more versions of software, according to at least one embodiment described in this disclosure. Figure 9 is described in conjunction with elements of Figures 1, 2, 3, 4, 5, 6, 7, and 8. Referring to Figure 9, flowchart 900 is shown. The method shown in flowchart 900 may begin at 902 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0143] In 902, a connection to one or more web-based sources 104 may be established. The processor 202 may be configured to establish a connection with one or more web-based sources 104 via the communication network 108.

[0144] In 904, system 102 may be configured to retrieve one or more versions of software that provide one or more APIs or functions to a software application. System 102 may be configured to retrieve one or more versions of software by sending API requests to one or more web-based sources 104.

[0145] In 906, system 102 may be configured to obtain a release date associated with each of one or more versions of the software. The release date may be the date on which the corresponding version of the software becomes available to the public for use, testing, and review.

[0146] In 908, system 102 may be configured to sort one or more versions of the software based on the release date of the corresponding software version. In one embodiment, system 102 may be configured to sort one or more versions of the software in ascending order. In another embodiment, system 102 may be configured to sort one or more versions of the software in descending order.

[0147] In 910, system 102 may be configured to retrieve a first set of messages related to the software from one or more web-based sources 104. Specifically, the first set of messages may be associated with one or more changes introduced into the source code of the software version. For example, on GitHub, each of the first set of messages may correspond to a pull request message.

[0148] In 912, system 102 may be configured to retrieve one or more labels in each of the first messages that are retrieved. Such labels may be collected to determine whether one or more changes introduced into a particular version of the source code of the software have been merged with corresponding versions of the code hosted on one or more web-based sources 104. One or more labels may include, for example, the values ​​of the keys "merged_at" and "merge_commit_sha". System 102 may be configured to consider messages that have the values ​​of the keys "merged_at" and "merge_commit_sha".

[0149] In 914, system 102 may be configured to select a message from a first set of messages. The first set of messages may be associated with one or more changes introduced in a particular version of the source code of the software.

[0150] In step 916, it may be determined whether the selected message is merged with a particular version of the software. Specifically, system 102 may be configured to determine whether the selected message has values ​​for the "merged_at" key and the "merge_commit_sha" key. If the selected message does not have values ​​for the "merged_at" key and the "merge_commit_sha" key, it may mean that the selected message is not merged with the corresponding version of the software, and control may be transferred to 918. Otherwise, control may be transferred to 920.

[0151] At 918, system 102 may be configured to ignore the selected first message and transfer control to 914. At 914, a new message may be selected from the set of first messages.

[0152] In 920, system 102 may be configured to collect the date on which the first message was merged with a specific version of the software. The merged date may correspond to the date on which the first message was associated with a specific version of the software. The merged date may correspond to the value of "merged_key".

[0153] In 922, system 102 may be configured to assign selected messages to specific versions of the software according to the merge date and the release date of the software version.

[0154] In 924, system 102 may be configured to store the corresponding version of the software in a third table of the first database, along with one or more messages from a first set of messages. System 102 may be configured to determine one or more messages from the first set of messages related to the corresponding version based on the merged date of the corresponding messages, and to store the corresponding version of the software in a third table of the first database, along with one or more messages from the first set of messages.

[0155] Control may be passed to termination. Flowchart 900 is illustrated with individual operations such as 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, and 924. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0156] Figure 10 illustrates a flowchart of an exemplary method for generating compatibility results based on software version-related messages, according to at least one embodiment described in this disclosure. Figure 10 is described in conjunction with the elements of Figures 1, 2, 3, 4, 5, 6, 7, 8, and 9. Referring to Figure 10, flowchart 1000 is shown. The method shown in flowchart 1000 may begin at 1002 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or Figure 2.

[0157] In 1002, system 102 may be configured to perform a pattern lookup operation (of a set of operations) for each of one or more messages in a first set of messages (included in the set of extracted data). One or more messages may be associated with a second version of the software. The pattern lookup operation may be performed to find one or more labels in the first set of messages. Similar to the first pattern lookup operation, the pattern operation may be a string lookup operation that can use one or more regular expressions to find one or more labels in the messages that are related to compatibility. Such labels may include words such as “breaking”, “break”, “incompatible”, and “breaking change”.

[0158] In 1004, it may be determined whether one or more labels are found in one or more messages of the first set of messages. If one or more labels are found, control may be transferred to 1006. Otherwise, control may be transferred to 1010.

[0159] In 1006, system 102 may be configured to extract a first set of messages from one or more messages. The extracted first set of messages may be associated with one or more labels found. Specifically, the extracted first set of messages may include one or more labels. One or more messages may indicate incompatibility of a second version of the software. An example of a message in the first set of messages is "Breaking change: The software may be implemented by disabling environment variable A".

[0160] In 1008, system 102 may be configured to determine a first set of API names or function names mentioned in the extracted first set of messages. The first set of API names or function names may be mentioned in the extracted first set of messages along with one or more labels found.

[0161] In 1010, system 102 may be configured to determine one or more first keywords in one or more messages. The one or more keywords may be semantically similar to one or more labels. Such keywords may include words such as "compatibility change," "stop," "interrupt," and "conflict." In some embodiments, system 102 may be configured to perform a fourth pattern lookup operation to detect one or more first keywords in one or more messages. System 102 may be configured to extract a second set of messages that may contain one or more first keywords.

[0162] In 1012, system 102 may be configured to determine a second set of API names or function names mentioned in the extracted second set of messages. Each of the extracted second set of messages may contain one or more first keywords and at least one API name from the second set of API names.

[0163] In 1014, a compatibility result may be generated. To generate a compatibility result, system 102 may be configured to determine whether a first set of determined API names or function names and / or a second set of determined API names or function names contain the names of one or more APIs or functions used in the source code of a software application. The compatibility result may be generated based on the determination that the first set of determined API names or function names and / or a second set of determined API names or function names contain the names of one or more APIs or functions used in the source code of a software application.

[0164] For example, if the determined tags and keywords (e.g., incompatible, broken, etc.) indicate broken compatibility, and the first set of determined API names or function names or the second set of determined API names or function names includes the names of one or more APIs or functions used in the source code of the software application, the compatibility result may indicate that one or more APIs or functions used in the source code of the software application are incompatible with a second version of the software. Otherwise, if the determined tags and keywords (e.g., compatible, consistent, etc.) indicate that compatibility is still maintained, and the first set of determined API names or function names or the second set of determined API names or function names includes the names of one or more APIs or functions used in the source code of the software application, the compatibility result may indicate that one or more APIs or functions used in the source code of the software application are compatible with a second version of the software.

[0165] Control may be passed to termination. Flowchart 1000 is illustrated with individual actions such as 1002, 1004, 1006, 1008, 1010, 1012, and 1014. However, in certain embodiments, such individual actions may be further divided into additional actions, combined into fewer actions, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0166] Figure 11 illustrates a flowchart of an exemplary method for extracting a file containing the source code of a second version of the software, according to at least one embodiment described in this disclosure. Figure 11 is described in conjunction with the elements of Figures 1, 2, 3, 4, 5, 6, 7, 8, 9, and 10. Referring to Figure 11, flowchart 1100 is shown. The method shown in flowchart 1100 may begin at 1102 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or Figure 2.

[0167] In 1102, system 102 may be configured to determine software that provides one or more APIs or functions to a software application (related to user 112). System 102 may determine software based on inputs received in relation to the software application.

[0168] In 1104, system 102 may be configured to retrieve one or more versions of the determined software. System 102 may be configured to retrieve one or more versions of the determined software from one or more web-based sources 104 from a first table of a first generated database.

[0169] In 1106, system 102 may be configured to sort each of the one or more versions of the determined software. In one or more embodiments, system 102 may be configured to sort each of the one or more versions of the determined software based on the release date associated with each version of the one or more versions of the determined software. In one embodiment, system 102 may be configured to sort the one or more versions of the software in ascending order of release date. In another embodiment, system 102 may be configured to sort the one or more versions of the software in descending order of release date.

[0170] In 1108, system 102 may be configured to determine source code changes between two consecutive versions of the determined software. For example, consecutive versions may include a first version of the software (v1.0) and a second version of the software (v2.0). The second version may be released immediately after the first version, and there may be no intermediate version of the software between the first and second versions.

[0171] In one embodiment, the system 102 may be configured to analyze and interpret information related to each version of the software to determine changes to the source code of each adjacent version pair of the determined software.

[0172] In 1110, system 102 may be configured to cluster the determined changes in the source code into one or more files. Each of these one or more files containing the determined changes in the source code may correspond to a first file.

[0173] In 1112, system 102 may be configured to cluster one or more code chunks in each of one or more files. Each code chunk may correspond to a modified block of source code in a second version of the software. Modifications introduced in the second version may be to the source code of the first version of the software. More specifically, each code chunk may correspond to one or more changes introduced in the source code of the second version of the software to the source code of the first version of the software.

[0174] In 1114, system 102 may be configured to store each of one or more code chunks in the memory of system 102. In some embodiments, system 102 may be configured to store each of one or more code chunks in a data structure for further processing. System 102 may use the stored one or more code chunks to determine the compatibility (or backward compatibility) of one or more APIs or functions (used in the source code of the software application (related to user 112)) for a second version of the software. In some embodiments, system 102 may be configured to store each of one or more code chunks in a first generated database.

[0175] Control may be passed to termination. Flowchart 1100 is illustrated with individual operations such as 1102, 1104, 1106, 1108, 1110, 1112, and 1114. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0176] In one embodiment, the second set of messages may include one or more changes that may be introduced into the source code of a second version of the software. Each of the second set of messages may be written by the developer or contributor about one or more changes that the developer or contributor may incorporate into the second version of the software. For example, each of the second messages may correspond to a commit message on GitHub.

[0177] In such a scenario, system 102 may be configured to perform the operation shown in Figure 11 to collect one or more code chunks from a second set of messages. Such code chunks may correspond to one or more changes introduced in the source code of a second version of the software compared to the source code of a first version of the software. System 102 may be configured to detect such changes in the source code using one or more regular expressions.

[0178] Figure 12 illustrates a flowchart of an exemplary method for generating compatibility results based on one or more collected code chunks, according to at least one embodiment described in this disclosure. Figure 12 is described in conjunction with elements of Figures 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, and 11. Referring to Figure 12, flowchart 1200 is shown. The method shown in flowchart 1200 may begin from 1202 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0179] System 102 may collect one or more code chunks from the extracted data set (as shown in Figures 1 and 6) that correspond to one or more changes in the source code of a second version of the software relative to the source code of a first version of the software. System 102 may then perform a second pattern search operation on the one or more code chunks to generate compatibility results. The second pattern search operation may be performed to determine the set of changes, as described herein.

[0180] In 1202, system 102 may be configured to determine a first change relating to the definition of a first function of one or more functions in a second version of the software. The first change may be determined for the first version of the software. One or more functions may be provided by the software for use in the source code of a software application. In some cases, such functions may be used in the source code of a software application. For example, the source code of a software application may include API call code, which, when executed, sends an API call to a server that executes a function based on parameters in the API call. If the source code of a software application uses the definition of a first version of the software, the first change in the definition may break backward compatibility. Details regarding the determination of the first change are provided in the example in Figure 14.

[0181] In 1204, system 102 may be configured to determine a second change to one or more changes in the set of input parameters of a first function. The changes may be determined in a second version of the software relative to a first version of the software. If the source code of the software application uses the set of input parameters from the first version of the software, the second change to the set of input parameters may break backward compatibility. Details regarding the determination of the second change are provided in the example in Figure 15.

[0182] In 1206, system 102 may be configured to determine a third change to one or more changes to one or more output parameters of a first function. The changes may be determined in a second version of the software relative to a first version of the software. If the source code of the software application uses the set of output parameters from the first version of the software, the third change to the set of output parameters may break backward compatibility. Details regarding the determination of the first change are provided in the example in Figure 16.

[0183] In 1208, system 102 may be configured to produce compatibility results. The compatibility results may include a definition of a first function from one or more functions or a definition of a first API from one or more APIs, one or more input parameters associated with the first function or first API, and one or more changes to one or more output parameters associated with the first function or first API.

[0184] Control may be passed to termination. Flowchart 1200 is illustrated with individual operations such as 1202, 1204, 1206, and 1208. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0185] Figure 13 illustrates a flowchart of an exemplary method for detecting a function definition according to at least one embodiment described in this disclosure. Figure 13 is described in conjunction with elements of Figures 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, and 12. Referring to Figure 13, flowchart 1300 is shown. The method shown in flowchart 1300 may begin from 1302 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or Figure 2.

[0186] Each programming language may have its own unique syntax that must be handled within the code. For example, the syntax for a function definition in Python might be "def f(para1, para2, ...):", in C / C++ it might be "typ0 f(typ1 para1, typ2 para2, ...) {...}", and in JavaScript it might be "function f(para1, para2) {...}".

[0187] In 1302, system 102 may be configured to detect one or more changes in each of one or more code chunks. Specifically, system 102 may be configured to detect one or more changes in the source code of a second version of the software compared to the source code of a first version of the software. In one embodiment, one or more changes may be associated with special characters. For example, the special character "+" may be prepended to all lines that may be added to the source code of a second version of the software. Similarly, the special character "-" may be prepended to all lines that exist in the first version of the software but not in the second version of the software. In such an embodiment, system 102 may be configured to detect special characters that may lead to the detection of one or more changes in each of one or more code chunks.

[0188] In some other embodiments, the number of lines added to and deleted in the second version of the source code may be present in the header section of the source code of the second version of the software. System 102 may use one or more regular expressions to detect special characters and / or header sections. For example, a regular expression for detecting a header section is:

number

[0189] In 1304, system 102 may be configured to perform a pattern matching operation to detect function definitions in a second version of the source code. The pattern matching operation may use regular expressions to detect function definitions. As an example, but not an exhaustive one, system 102 may be configured to detect function definitions by detecting one or more keywords such as "def", "type", "," and "return".

[0190] In 1306, it can be determined whether the data type associated with each function definition is explicitly defined. In some programming languages, the data type of a function (often known as the return type) is explicitly defined. For example, in Java, C, and C++, the data type (or return type) of any function is explicitly defined. In some programming languages, the data type of a function may not be explicitly defined. Such programming languages ​​include, but are not limited to, Python 2 and Ruby. If the data type associated with the function definition is explicitly defined, control may be moved to 1308. Otherwise, control may be moved to 1310.

[0191] In 1308, system 102 may be configured to collect data types associated with the corresponding function and data types associated with the set of input parameters of the function. System 102 may be configured to store the collected data types associated with the corresponding function, and the data types associated with the set of input parameters of the function, along with the name of the corresponding function, in a first database.

[0192] In 1310, system 102 may analyze the function definition (of a function whose return type is not explicitly defined) to find a set of input parameters associated with the function. System 102 may be configured to further analyze the function definition to find one or more output parameters (or return parameters) of the corresponding function.

[0193] In 1312, system 102 may be configured to collect the data type of each parameter in the detected set of input parameters, and the data type of one or more output parameters of the function. System 102 may be configured to store the collected data types along with the function name in a first database.

[0194] Control may be passed to termination. Flowchart 1300 is illustrated with individual operations such as 1302, 1304, 1306, 1308, 1310, and 1312. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0195] Figure 14 illustrates a flowchart of an exemplary method for determining a first modification in the function definition of one or more functions, according to at least one embodiment described herein. Figure 14 is described in conjunction with elements of Figures 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, and 13. Referring to Figure 14, flowchart 1400 is shown. The method shown in flowchart 1400 may begin from 1402 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0196] In 1402, system 102 may be configured to determine the function definition of a first function among one or more functions in a first code chunk of one or more code chunks. In one embodiment, system 102 may be configured to determine the function definition based on special characters ("+" and "-"). As described above, a "+" special character may be prepended to any new line of code that may be added to the source code of a second version of the software. Similarly, a "-" special character may be prepended to all lines of code that exist in the first version of the software but not in the second version of the software. System 102 may analyze each line containing the special characters ("+" and "-") and determine the function definition.

[0197] In 1404, it can be determined whether the first function was deleted or renamed in the second version of the source code relative to the first version of the code. For example, if the first function (e.g., Fun A()) exists in the first version of the software but not in the second version, system 102 may determine that the first function was deleted or renamed in the second version of the software. Such a determination may be based on special characters related to the addition or deletion of lines in the source code of the second version. If the first function exists in the second version of the software, control may be transferred to 1406. Otherwise, if the first function was deleted or renamed in the second version, this may be determined as a first change in the function definition, and control may be transferred to 1414.

[0198] In 1406, it can be determined whether the visibility of a first function has changed in a second version of the software compared to a first version of the software. Specifically, system 102 can be configured to determine whether the access modifier of the first function has changed in the second version compared to the first version. The access modifier can specify the accessibility or scope of the first function. For example, Java has four access modifiers: private, public, protected, and default. If the first function is defined as "public fun A()" in the first version of the software and the same first function is defined as "private fun A()" in the second version of the software, it can be determined that the visibility of the first function has changed.

[0199] In one embodiment, system 102 may be configured to use a regular expression to determine whether the visibility of the first function has been changed. If the visibility of the first function in the first version of the software is the same as the visibility of the first function in the second version of the software, control may be moved to 1408. Otherwise, the change in visibility may be determined as a first change in the function definition, and control may be moved to 1414.

[0200] In 1408, it may be determined whether the high-risk modifiers of the first function have been changed from the first version of the software to the second version of the software. Specifically, system 102 may be configured to determine whether certain keywords (e.g., final, default, static, this, or super) apply to the first function in the second version of the software. Such keywords may be missing in the first version or may have been changed in the update from the first version to the second version. If no high-risk modifiers have been added to the first function in the second version of the software, or have not been changed in the second version, control may proceed to 1410. Otherwise, if at least one high-risk modifier has been added to the definition of the first function in the second version of the software, the addition may be determined as the first change, and control may proceed to 1414.

[0201] In 1410, it may be determined whether there are any changes in the inheritance of the class related to the first function. Inheritance can be defined as the process by which one class acquires properties (methods and fields) of another class. If there are no changes in the inheritance of the class between the second version of the software and the first version of the software, control may be moved to 1412. Otherwise, control may be moved to 1414.

[0202] In 1412, system 102 may output that the first function does not break compatibility with respect to the function definition. In such cases, it may be determined that there are no changes in the first function with respect to the definition of the first function.

[0203] In 1414, a first change may be determined, and system 102 may be configured to add the first function to the list of breakable functions. As discussed above, the first change may be determined based on at least one of the following: renaming the first function, changing the access modifier of the first function, changing the high-risk modifier of the first function, deleting the first function, and changing the inheritance of the first function. The list of breakable functions may be stored in a first database for further reference.

[0204] In cases where a first change is determined, system 102 may be further configured to generate compatibility results. The generated compatibility results may indicate backward compatibility of the first function used in the source code of the software application with respect to a second version of the software. Based on the generated compatibility results, system 102 may be further configured to control display device 106 to display support information notifying of the incompatibility of the first function used in the source code of the software application with respect to a second version of the software.

[0205] Control may be passed to termination. Flowchart 1400 is illustrated with individual operations such as 1402, 1404, 1406, 1408, 1410, 1412, and 1414. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0206] Figure 15 illustrates a flowchart of an exemplary method for determining a second change in a set of input parameters for one or more functions, according to at least one embodiment described herein. Figure 15 is described in conjunction with elements of Figures 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, and 14. Referring to Figure 15, flowchart 1500 is shown. The method shown in flowchart 1500 may begin from 1502 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0207] In 1502, system 102 may be configured to determine the data type and name of each input parameter in the set of input parameters for the first function. In one embodiment, the data type and name of each input parameter may be determined based on special characters ("+" and "-") and / or one or more regular expressions.

[0208] In 1504, system 102 may be configured to determine whether the count of the set of input parameters in the second version of the software is the same as the count of the set of input parameters in the first version of the software. If the counts are different, control may proceed to 1506. Otherwise, control may proceed to 1508.

[0209] In 1506, it may be determined whether one or more different input parameters in the second version of the software have associated default values. Such parameters may include additional parameters that may be presented in the second version of the software but not in the first version. If one or more different input parameters have default values, control may proceed to 1508. Otherwise, a second change in the set of input parameters of the first function may be determined, and control may proceed to 1518.

[0210] As an example, not an exhaustive one, if a function A is defined as "int funA(int x);" in the first version of the software, and the same function is defined as "int funA(int x, int y = 3);", then control may be migrated to 1508. If the same function is defined as "int funA(int x, int y);" in the second version of the software, then control may be migrated to 1518 because the variable "y" does not have a default value.

[0211] In 1508, it can be determined whether each of the input parameter sets is associated with the same data type as in the first version of the software. If the data type associated with the input parameter set is different from that in the first version of the software, control may proceed to 1510. Otherwise, control may proceed to 1512.

[0212] In 1510, it can be determined whether each of the one or more different input parameters has a loose data type associated with it. A loose data type can accept values ​​of other data types as well as values ​​associated with the loose data type. For example, in the C programming language, the data type "float" is used primarily to accept float numbers. However, "float" can also accept integers. In this case, the compiler automatically converts one data type to another when it makes sense. For example, when assigning an integer value to a floating-point variable, the compiler converts int to float. On the other hand, the data type int, which is primarily used for integer data, cannot accept float. Therefore, "float" can be named a loose data type, while "int" cannot be considered a loose data type. If each of the one or more different input parameters has a loose data type, control can proceed to 1512. Otherwise, control can proceed to 1518.

[0213] In 1512, it can be determined whether each parameter in the set of parameters has the same name and order in the second version of the software as it did in the first version. The order can identify the sequence in which such parameters appear within the function definition of the first function of one or more functions. If the set of input parameters has different names and / or a different order in the second version of the software (compared to the first version), control may proceed to 1514. Otherwise, control may proceed to 1516. As an example, if a variable is defined as "int A" in the first version of the software and as "int Z" in the second version, control may proceed to 1514.

[0214] In 1514, it can be determined whether each of the one or more different input parameters corresponds only to symbol changes. If such an input parameter corresponds only to symbol changes, control may proceed to 1516. Otherwise, control may proceed to 1518.

[0215] In 1516, system 102 may output the first function in such a way that it does not break compatibility with respect to the set of input parameters. In such a case, no change in the first function can be determined with respect to the set of input parameters.

[0216] In 1518, a second change may be determined, and system 102 may be configured to add the first function to the list of breakable functions. As described above, the second change may be determined based on at least one of the following: a change in the count of input parameters of the first function; a change in the default value of one or more input parameters of the first function; a change in the data type of one or more input parameters of the first function; a change in the name of one or more input parameters of the first function; and a change in the order of one or more input parameters. The list of breakable functions may be stored in the first database for further reference.

[0217] In cases where a second change is determined, system 102 may be further configured to generate compatibility results. The generated compatibility results may indicate backward compatibility of the first function used in the source code of the software application with respect to the second version of the software. Based on the generated compatibility results, system 102 may be further configured to control display device 106 to display support information notifying of the incompatibility of the first function used in the source code of the software application with respect to the second version of the software.

[0218] Control may be passed to termination. Flowchart 1500 is illustrated with individual operations such as 1502, 1504, 1506, 1508, 1510, 1512, 1514, 1516, and 1518. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0219] Figure 16 illustrates a flowchart of an exemplary method for determining a third change in one or more output parameters of a function, according to at least one embodiment described herein. Figure 16 is described in conjunction with elements of Figures 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, and 15. Referring to Figure 16, flowchart 1600 is shown. The method shown in flowchart 1600 may begin from 1602 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0220] In 1602, system 102 may be configured to determine the data type and name of each of one or more output parameters of the first function. In one embodiment, system 102 may be configured to determine the data type and name of each of one or more output parameters of the first function based on special characters ("+" and "-").

[0221] In 1604, it may be determined whether the return value of the first function is changed to a function call to the second function. System 102 may determine the return value of the first function in the first version of the software and compare the determined value with the return value of the first function in the second version of the software. If the return value of the first function is a call to the second function, control may be transferred to 1606. Otherwise, control may be transferred to 1608.

[0222] In 1606, system 102 may be configured to detect a second function whose call is made by the first function. System 102 may be configured to detect the second function by analyzing the source code of a second version of the software.

[0223] In 1608, system 102 may be configured to determine whether the count of one or more output parameters of the first function (or second function) in the second version of the software is the same as the count of the set of output parameters of the first function in the first version of the software. If the measured counts are the same, control may proceed to 1610. Otherwise, control may proceed to 1624. As an example, if function A is defined in the first version of the software as "def funA (x) return m" and the same function is defined as "def funA (x) return m,n", control may proceed to 1624 because the count of the output parameters has increased from 1 in the first version to 2 in the second version.

[0224] In 1610, it may be determined whether the data type of one or more output parameters of the first function (or second function) in the second version of the software is the same as the data type of one or more output parameters in the first version of the software. If the data types are different in both versions, control may proceed to 1612. Otherwise, control may proceed to 1614.

[0225] In 1612, it can be determined whether the data type of one or more different output parameters is a loose data type. Each of these different output parameters may have a different data type between the second version of the software and the first version of the software. If the data type is a loose data type, control can proceed to 1614. Otherwise, control can proceed to 1624.

[0226] In 1614, it may be determined whether the names and order of one or more output parameters are the same in both the first and second versions of the software. If the names and / or order of one or more output variables differ in the second version compared to the first version, control may be transferred to 1616. Otherwise, control may be transferred to 1618.

[0227] In 1616, it can be determined whether each of the one or more different output parameters is merely a symbol change. If one or more different output parameters are merely symbol changes, control can proceed to 1618. Otherwise, control can proceed to 1624.

[0228] In 1618, it may be determined whether one or more exceptions have changed from the first version of the software to the second version. If one or more exceptions have changed, control may proceed to 1620. Otherwise, control may proceed to 1622.

[0229] In 1620, it may be determined whether a change in one or more exceptions results in a change to an exception in the source code of the software application (associated with user 112). If the change in one or more exceptions does not result in a change to an exception in the source code of the software application, control may be transferred to 1622. Otherwise, control may be transferred to 1624.

[0230] In 1622, system 102 may output that the first function does not break compatibility with respect to one or more output parameters. In such cases, a change in the first function can be determined with respect to a set of input parameters.

[0231] In 1624, a third change may be determined, and system 102 may be configured to add the first function to the list of breakable changes. As described above, the third change is determined based on at least one of the following: a change in the count of one or more output parameters of the first function; a change in the data type of one or more output parameters of the first function; a change in the name of one or more output parameters of the first function; and a change in the order of one or more output parameters. The list of breakable changes may be stored in the first database for further reference.

[0232] If a third change is decided, system 102 may be further configured to generate compatibility results. The generated compatibility results may indicate backward compatibility of the first function used in the source code of the software application with respect to a second version of the software. Based on the generated compatibility results, system 102 may be further configured to control display device 106 to display support information notifying of the incompatibility of the first function used in the source code of the software application with respect to a second version of the software.

[0233] Control may be passed to termination. Flowchart 1600 is illustrated with individual operations such as 1602, 1604, 1606, 1608, 1610, 1612, 1614, 1616, 1618, 1620, 1622, and 1624. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0234] Figure 17 illustrates an exemplary electronic user interface (UI) for displaying support information on a display device, according to at least one embodiment described in this disclosure. Figure 17 is described in conjunction with elements of Figures 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, and 16. Referring to Figure 17, an electronic UI 1700 is shown, which may be an exemplary implementation of the electronic UI 110 of Figure 1. The electronic UI 1700 may be displayed on the display device 106 based on the generated compatibility result.

[0235] The electronic UI 1700 displays a set of UI elements, such as a first UI element 1702, a second UI element 1704, and a third UI element 1706. The first UI element 1702 may be labeled, for example, "Compatibility Result". The first UI element 1702 may be a label window that can show the compatibility result for a second version of the software. The generated compatibility result may show backward or forward compatibility of one or more APIs or functions used in the source code of the software application with respect to the second version of the software. If one or more APIs or functions used in the source code of the software application are backward or forward compatible with respect to the second version of the software, "Yes" may be displayed on the first UI element 1702. In some embodiments, the first UI element 1702 may also include a first recommendation to update the source code of the software application to source code compatible with the second version of the software.

[0236] If one or more APIs or functions used in the source code of a software application are not backward compatible or forward compatible with a second version of the software, "No" may be displayed on the first UI element 1702. If one or more APIs or functions used in the source code of a software application are not backward compatible or forward compatible with a second version of the software, the second UI element 1704 and the third UI element 1706 may be displayed on the electronic UI 1700.

[0237] The second UI element 1704 may be labeled, for example, "Alternative Version". The second UI element 1704 may be a text box that can display a second recommendation to upgrade to a third version of the software, which may differ from the first and second versions of the software. One or more APIs or functions used in the source code of the software application may be backward or forward compatible with the third version of the software.

[0238] The second UI element 1706 is labeled, for example, "Reasons for Incompatibility." The third UI element 1706 may be a text box that can display a set of reasons explaining the cause of backward or forward compatibility of one or more APIs or functions used in the source code of the software application to a second version of the software. In one embodiment, the system 102 may be configured to generate a set of reasons in natural language that can explain one or more causes of backward compatibility of one or more APIs or functions (used in the source code of the software application) to a second version of the software. For example, one or more causes may be that the count of input parameters for the first function has decreased from the first version to the second version.

[0239] Figure 18 illustrates a flowchart of an exemplary method for detecting APIs between software versions according to at least one embodiment described in this disclosure. Figure 18 is described in conjunction with elements of Figures 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, and 17. Referring to Figure 18, flowchart 1800 is shown. The method shown in flowchart 1800 may begin from 1802 and may be performed by any preferred system, apparatus, or device, such as system 102 in Figure 1 or 2.

[0240] In 1802, input related to a software application may be received. The received input may include at least one of the following: the source code of the software application, a portion of the source code that may relate to one or more APIs or functions, text information containing first data related to one or more APIs or functions, second data related to the name of the software that provides one or more APIs or functions, and third data related to a first version of the software. Details regarding the reception of input are provided in Figures 1 and 3.

[0241] In 1804, the first information may be determined based on the received input. The first information may be about one or more application programming interfaces (APIs) or functions that may be used in the source code of the software application. Additionally, the first information may be about a first version of the software that provides one or more APIs or functions. Details on determining the first information are provided in the example in Figure 5.

[0242] In 1806, the data set may be hosted on one or more web-based sources 104. The data set may be extracted based on the first determined information. The extracted data set may include one or more changes in the source code of a second version of the software, which may differ from the first version of the software. The extracted data set may further include second information about one or more changes in the second version. Details on the extraction of the data set are provided in Figures 6, 7, 9, and 11.

[0243] In 1808, a set of data may be executed. A set of actions may include one or more pattern search actions. A set of actions may be executed on the extracted set of data to produce compatibility results. Compatibility results may be produced for one or more code changes and second information.

[0244] In some embodiments, compatibility results may be generated based on at least two of the following: a first file, a second file, a third file, a first set of messages, or a second set of messages. In embodiments, compatibility results may be generated based on a voting-based approach. For example, if performing a set of actions on a first file indicates that the first API is not backward compatible, performing a set of actions on a second file indicates that the first API is not backward compatible, and performing a set of actions on a first set of messages indicates that the first API is backward compatible, then the generated compatibility result may indicate that the first API is not backward compatible because two of the three results indicate that the first API is not backward compatible.

[0245] In another embodiment, compatibility results may be generated based on a weight-based approach. In such a scenario, weights may be assigned to the compatibility results generated based on the execution of each set of operations for the first file, the second file, the first set of messages, and the second set of messages. Details regarding the determination of compatibility results are provided, for example, in Figures 8, 10, and 12.

[0246] In 1810, the display device 106 may be controlled based on the generated compatibility results. The display device 106 may be configured to display support information that informs about the compatibility of one or more APIs or functions used in the source code of the software application with respect to a second version of the software. Details on displaying support information are provided in the example in Figure 17.

[0247] Control may be passed to termination. Flowchart 1800 is illustrated with individual operations such as 1802, 1804, 1806, 1808, and 1810. However, in certain embodiments, such individual operations may be further divided into additional operations, combined into fewer operations, or deleted, depending on the particular embodiment, without prejudice to the essence of the disclosed embodiments.

[0248] In one embodiment, system 102 may be configured to perform data set extraction and a set of operations before receiving input, as shown in Figure 4. System 102 may further be configured to store a set of compatibility results in a database (or first database) based on the data set extraction and the execution of the set of operations. As an example, but not an limitation, a first table of the first database is provided in Table 2 as follows. [Table 2] System 102 can receive input at any time and query the database based on the received input. In some cases, APIs may change back and forth, especially between several already released versions. For example, Table 2 shows that API 1 is not backward compatible from v1.1 to v1.2 and v1.3. However, in version v1.3.1, API 1 has been changed to revert to its original format, like v1.1. In such cases, backward compatibility can be determined by examining the table above. For example, if a user wants to upgrade from v1.1 to v1.3, API 1 will break backward compatibility, but if a user wants to upgrade from v1.1 to v1.3.1, API 1 will not break backward compatibility.

[0249] In one embodiment, compatibility results related to the received input may exist in a database. In such an embodiment, system 102 may retrieve the compatibility results from the database and control the display device 106 to display support information based on the compatibility results. In scenarios where the results are already stored in the database, system 102 may be said to be operating in pre-processing mode. In pre-processing mode, the time required to display support information may be reduced because the results may already be stored in the database.

[0250] In another embodiment, compatibility results related to the received input may not exist in the database. In such an embodiment, system 102 may extract a set of data from one or more web-based sources 104 and perform a set of actions to generate compatibility. In scenarios where the results are not stored in the database, system 102 may be said to be operating in dynamic mode. In dynamic mode, database maintenance is not required. The time it takes to display the support information may be longer in dynamic mode than in preprocessing mode.

[0251] In one embodiment, system 102 may run in hybrid mode (i.e., both preprocessing mode and dynamic mode). In such a scenario, system 102 may be configured to receive inputs or to retrieve compatibility results related to a first input from a database (as is done in the case of preprocessing mode). In cases where no compatibility results related to the input exist in the database, system 102 may be configured to extract data from one or more web-based sources 104 or to receive a set of operations and generate compatibility results for the received input (as is done in the case of dynamic mode).

[0252] In one embodiment, the system 102 may be configured to extract a set of data from a first database instead of one or more web-based sources 104, and may perform a set of operations to generate compatibility results. In another embodiment, compatibility results for different versions of each software in the collection may already be stored in the first database. In such an embodiment, the system 102 may be configured to retrieve compatibility results from the first database and may control the display device 106 based on the retrieved compatibility results.

[0253] Various embodiments of this disclosure may provide one or more non-temporary computer-readable storage media configured to store instructions causing a system (such as system 102) to perform an action in response to being executed. This action may include receiving input related to a software application. Based on the input, this action may further include determining one or more application programming interfaces (APIs) or functions used in the source code of the software application, and first information about a first version of the software that provides one or more APIs or functions. Based on the determined first information, this action may further include extracting a set of data from one or more web-based sources (such as one or more web-based sources 10). The extracted set of data may include one or more changes in the source code of a second version of the software, and second information about one or more changes in the second version. The second version of the software may differ from the first version of the software. This action may further include performing a set of actions, including one or more pattern lookup actions, on the extracted set of data to generate compatibility results. This action may further include controlling a display device (such as display device 106) based on the generated compatibility results. The display device may be configured to display support information that informs about the compatibility of one or more APIs or functions used in the source code of the software application with respect to a second version of the software.

[0254] As described above, embodiments described herein may involve the use of a special-purpose or general-purpose computer (e.g., processor 202 in Figure 2) including various computer hardware or software modules, as will be discussed in more detail below. Furthermore, as described above, embodiments described herein may be implemented using a computer-readable medium (e.g., memory 204 or persistent data storage 206 in Figure 2) for carrying or storing computer-executable instructions or data structures.

[0255] As used in this disclosure, the terms “module” or “component” may refer to a software object or software routine that can be stored and / or executed in a particular hardware implementation and / or general-purpose hardware of a computing system (e.g., computer-readable media, processing devices, or some other hardware) configured to perform the actions of a module or component. In some embodiments, different components, modules, engines, and services described in this disclosure may be implemented as objects or processes that run on a computing system (e.g., as separate threads). While some of the systems and methods described in this disclosure are generally described as being implemented in software (stored and / or executed by general-purpose hardware), specific hardware implementations or combinations of software and specific hardware implementations are also possible and intended. In this description, “computation entity” may be any computing system as previously defined in this disclosure, or any combination of modules or modulators operating on a computing system.

[0256] In accordance with general practice, various features shown in the drawings may not be depicted to scale. The illustrations presented in this disclosure are not intended to be actual drawings of any particular apparatus (e.g., apparatus, system, etc.) or method, but are merely idealized representations used to describe various embodiments of this disclosure. Accordingly, the dimensions of various features may be enlarged or reduced as appropriate for clarity. In addition, parts of the drawings may be simplified for clarity. Accordingly, the drawings may not depict all components of a given apparatus (e.g., device) or all operations of a particular method.

[0257] In this disclosure, the terms used in particular in the attached claims (e.g., the text of the attached claims) are generally intended to be “open” terms (for example, the term “contains” should be interpreted as “contains, but not limited to,” the term “has” should be interpreted as “has at least,” and the term “contains” should be interpreted, in particular, as “contains, but not limited to.”).

[0258] Furthermore, if a specific number of introduced claims are intended, such intent is explicitly stated in the claims; if there is no such provision, such intent does not exist. For example, to aid understanding, the following appended claims may contain the use of the introductory phrases “at least one” and “one or more” to introduce the provisions of the claims.

[0259] Additionally, even if a specific number of provisions in an introduced claim is explicitly specified, a person skilled in the art will recognize that such a provision should be interpreted as meaning at least the specified number (for example, the mere provision "two provisions," without other modifiers, means at least two provisions, or two or more provisions). Furthermore, where a similar convention is used, such a structure is generally intended to include A alone, B alone, C alone, A and B, A and C, B and C, or A, B and C, etc.

[0260] Furthermore, any word or phrase presenting two or more alternative terms, whether in the specification, claims, or drawings, should be understood to intend one of those terms, either of those terms, or both of those terms. For example, the phrase "A or B" should be understood to include the possibilities of "A" or "B" or "A and B".

[0261] However, the use of such phrases should not be interpreted as suggesting that the introduction of a claim provision by the indefinite article “a” or “an” limits any particular claim containing such introduced provision to only one embodiment containing such provision, and this is also true when the same claim contains the indefinite article such as the introductory phrase “one or more” or “at least one” and “a” or “an” (for example, “a” and / or “an” should be interpreted as meaning “at least one” or “one or more”), and the same is true in the case of the use of an indefinite article used to introduce a claim provision.

[0262] Furthermore, the use of terms such as “first,” “second,” and “third” is not necessarily used in this specification to imply a particular order or number of elements. Generally, terms such as “first,” “second,” and “third” are used as general identifiers to distinguish different elements. Terms such as “first,” “second,” and “third” should not be understood to imply a particular order without indicating that they do. Furthermore, terms such as “first,” “second,” and “third” should not be understood to imply a particular number of elements without indicating that they do. For example, it may be stated that the first widget has a first aspect, and the second widget has a second aspect. The use of the term “second aspect” with respect to the second widget may distinguish such aspect of the second widget from the “first aspect” of the first widget and not imply that the second widget has two aspects.

[0263] All examples and conditional language set forth in this disclosure are intended for educational purposes to assist the reader in understanding the concepts to which the disclosure and the inventors have contributed to advancing the art, and should be construed as not being limited to such specifically set forth examples and conditions. While embodiments of this disclosure are described in detail, it should be understood that various modifications, substitutions, and exchanges may be made thereto without departing from the spirit and scope of this disclosure.

[0264] The following additional information is disclosed regarding the embodiments described above. (Note 1) It is a method, Receiving input related to a software application, Based on the above input, One or more application programming interfaces (APIs) or functions used in the source code of the aforementioned software application, and Determining first information about a first version of software that provides one or more APIs or functions, Based on the first information described above, extract a set of data from one or more web-based sources, wherein the set of data is: One or more changes in the source code of a second version of the software that is different from the first version of the software, and Extracting information including second information about one or more changes in the second version, The process involves performing a set of operations, including one or more pattern search operations, on the aforementioned data set to generate compatibility results. A method comprising controlling a display device based on the compatibility results to display support information about one or more APIs or functions used in the source code of the software application for a second version of the software. (Note 2) The method described in Appendix 1, wherein the software is open-source software (OSS) or proprietary software. (Note 3) The input includes at least one of the following: the source code of the software application, a portion of the source code relating to one or more APIs or functions, or text information. The method according to Appendix 1, wherein the text information includes first data relating to one or more APIs or functions, second data relating to the name of the software providing the one or more APIs or functions, and third data relating to a first version of the software. (Note 4) Determining a collection of software that provides a collection of APIs or functions hosted on one or more web-based sources, Collecting software metadata for each software in the determined software collection from one or more web-based sources, The software metadata to be collected includes at least one of the following: the name of the software, one or more versions of each software in the software collection, and information about the programming language used in each of the one or more versions of each software. Collect API metadata from one or more web-based sources relating to the set of APIs included in each of the one or more versions; The method further includes storing the software metadata and the API metadata in a first database, The first information is determined from the first database, according to the method described in Appendix 1. (Note 5) The method described in Appendix 4, wherein the input includes the source code of the software application. (Note 6) Reading the source code included in the input, Analyzing one or more definition files related to the loaded source code to determine the version information of the software, and Querying the first database using the version information to determine the first information about the one or more APIs or functions used in the source code of the software application, the method according to appendix 5 further comprising. (Appendix 7) The set of extracted data A first file including the source code of the second version of the software, A second file including the second information, A third file including an explanation of the software, and A set of first messages related to one or more changes introduced into the source code of the second version of the software, the method according to appendix 1. (Appendix 8) The performing Performing a first pattern search operation of the set of operations on the set of data to detect one or more tags related to compatibility in the set of data, Extracting one or more sentences related to the one or more tags, Determining a first set of API names or function names mentioned in the one or more sentences, Determining whether the first set of API names or function names includes the names of the one or more APIs or functions used in the source code of the software application, further comprising, The compatibility result is further generated based on the determination that the first set of API names or function names includes the names of the one or more APIs or functions used in the source code of the software application, the method according to appendix 1. (Appendix 9) The compatibility result is Definition of the first function among the aforementioned functions or the first API among the one or more aforementioned APIs, One or more input parameters related to the first function or the first API, and The method according to Appendix 8, comprising modifying one or more output parameters associated with the first function or the first API. (Note 10) The aforementioned actions further include, From the extracted data set, collect one or more code chunks corresponding to one or more changes in the source code of the second version of the software to the source code of the first version of the software, The method according to Appendix 1, comprising performing a second pattern lookup operation of the set of operations on one or more code chunks to generate the compatibility result. (Note 11) The second pattern search operation described above involves selecting from one or more code chunks, A first change relating to the definition of the first of one or more functions, A second change among the one or more changes in the set of input parameters of the first function, and The method according to Appendix 10, wherein the compatibility result is performed by determining a third modification of the one or more modifications in one or more output parameters of the first function, the third modification which is further generated based on at least one of the first modification, the second modification, and the third modification. (Note 12) The first change described above is, Renaming the first function, Change the access modifier of the first function, Deletion of the first function, and The method according to Appendix 11, determined based on at least one of the changes in the inheritance of the first function described above. (Note 13) The second change described above is: Changing the count of the input parameters of the first function, Changing the default value of one or more input parameters of the first function, Changing the data type of one or more input parameters of the first function, Renaming one or more input parameters of the first function, and The method according to Appendix 11, determined based on at least one of the changes in the order of the one or more input parameters. (Note 14) The third change described above is: Changing the count of one or more output parameters of the first function, Changing the data type of one or more output parameters of the first function, Renaming one or more output parameters of the first function, and The method according to Appendix 11, determined based on at least one of the changes in the order of the one or more output parameters. (Note 15) Before receiving the aforementioned input, the extraction of the data set and the execution of the set of operations are performed, Based on the above implementation, the set of compatibility results is stored in the database, The method according to Appendix 1, further comprising querying the database based on the received input to generate the compatibility result. (Note 16) The method according to Appendix 1, wherein the compatibility result indicates that one or more APIs or functions used in the source code of the software application are not backward compatible with the second version of the software. (Note 17) The aforementioned support information is, A first recommendation for updating the source code of the software application to source code compatible with the second version of the software. A second recommendation to update to a third version of the software that is different from the first or second version of the software, and The method according to Appendix 1, comprising one or more reasons from a set of reasons that explain the incompatibility of one or more APIs or functions used in the source code of the software application with respect to the second version of the software. (Note 18) One or more non-temporary computer-readable storage media configured to store instructions, wherein the instructions cause the system to perform an action in response to being executed, and the action is: Receiving input related to a software application, Based on the above input, One or more application programming interfaces (APIs) or functions used in the source code of the aforementioned software application, and Determining first information about a first version of software that provides one or more APIs or functions, Based on the first information described above, extract a set of data from one or more web-based sources, wherein the set of data is: One or more changes in the source code of a second version of the software that is different from the first version of the software, and Extracting information including second information about one or more changes in the second version, The process involves performing a set of operations, including one or more pattern search operations, on the aforementioned data set to generate compatibility results. A non-temporary computer-readable storage medium, which includes controlling a display device based on the compatibility results to display support information about one or more APIs or functions used in the source code of the software application for a second version of the software. (Note 19) The aforementioned operation is, Execute a first pattern search operation of the set of operations on the set of data to detect one or more tags related to compatibility in the set of data; Extract one or more sentences related to the one or more tags; Determine a first set of API names or function names mentioned in the one or more sentences; Determine whether the first set of API names or function names includes the names of the one or more APIs or functions used in the source code of the software application, and further include: The compatibility result is further generated based on the determination that the first set of API names or function names includes the names of the one or more APIs or functions used in the source code of the software application, in the non - transient computer - readable storage medium described in Appendix 18. (Appendix 20) A system, Including a processor, the processor Receives an input related to a software application, Based on the input, One or more application programming interfaces (APIs) or functions used in the source code of the software application, and Determine first information about a first version of software that provides the one or more APIs or functions; Extract a set of data from one or more web - based sources based on the first information, the set of data Includes one or more changes in the source code of a second version of the software that is different from the first version of the software, and Extract, including second information about the one or more changes in the second version; The process involves performing a set of operations, including one or more pattern search operations, on the aforementioned data set to generate compatibility results. A system configured to control a display device based on the compatibility results to display support information about one or more APIs or functions used in the source code of the software application for a second version of the software.

Claims

1. It is a method, Receiving input related to a software application, Based on the above input, One or more application programming interfaces (APIs) or functions used in the source code of the software application, and Determining first information about a first version of software that provides one or more APIs or functions, Based on the first information described above, extract a set of data from one or more web-based sources, wherein the set of data is: One or more changes in the source code of a second version of the software that is different from the first version of the software, and Extracting information including second information about one or more changes in the second version, The process involves performing a set of operations, including one or more pattern search operations, on the aforementioned data set to generate compatibility results. A method comprising controlling a display device based on the compatibility results to display support information for one or more APIs or functions used in the source code of the software application for a second version of the software.

2. The method according to claim 1, wherein the software is open-source software (OSS) or proprietary software.

3. The input includes at least one of the following: the source code of the software application, a portion of the source code relating to one or more APIs or functions, or text information. The method according to claim 1, wherein the text information includes first data relating to one or more APIs or functions, second data relating to the name of the software providing the one or more APIs or functions, and third data relating to a first version of the software.

4. Determining a collection of software that provides a collection of APIs or functions hosted on one or more web-based sources, Collecting software metadata for each software in the determined software collection from one or more web-based sources, The software metadata to be collected includes at least one of the following: the name of the software, one or more versions of each software in the software collection, and information about the programming language used in each of the one or more versions of each software. Collect API metadata from one or more web-based sources relating to the set of APIs included in each of the one or more versions; The method further includes storing the software metadata and the API metadata in a first database, The method according to claim 1, wherein the first information is determined from the first database.

5. The method according to claim 4, wherein the input includes the source code of the software application.

6. Reading the source code included in the input, The software version information is determined by analyzing one or more definition files related to the loaded source code. The method of claim 5, further comprising querying the first database using the version information to determine the first information about one or more APIs or functions used in the source code of the software application.

7. The extracted set of data is: A first file containing the source code of the second version of the software, A second file containing the aforementioned second information, A third file containing a description of the aforementioned software, and The method according to claim 1, comprising a set of first messages relating to one or more changes introduced into the source code of the second version of the software.

8. The aforementioned actions are, Performing a first pattern search operation of the set of operations on the set of data to detect one or more tags related to compatibility in the set of data, Extracting one or more sentences related to the one or more tags mentioned above, Determine a first set of API names or function names mentioned in one or more of the above sentences, The method further includes determining whether the first set of API names or function names includes the names of one or more APIs or functions used in the source code of the software application, The method according to claim 1, wherein the compatibility result is further generated based on the determination that the first set of API names or function names includes the names of one or more APIs or functions used in the source code of the software application.

9. The aforementioned compatibility results are, Definition of the first function among the aforementioned functions or the first API among the one or more aforementioned APIs, One or more input parameters related to the first function or the first API, and The method according to claim 8, comprising modifying one or more output parameters associated with the first function or the first API.

10. The aforementioned actions further include, From the extracted data set, collect one or more code chunks corresponding to one or more changes in the source code of the second version of the software to the source code of the first version of the software, The method according to claim 1, comprising performing a second pattern lookup operation of the set of operations on one or more code chunks to generate the compatibility result.

11. The second pattern search operation described above involves selecting from one or more code chunks, A first change relating to the definition of the first of one or more functions, A second change among the one or more changes in the set of input parameters of the first function, and The method according to claim 10, wherein the compatibility result is performed by determining a third modification of the one or more modifications in one or more output parameters of the first function, the third modification being further generated based on at least one of the first modification, the second modification, and the third modification.

12. The first change described above is: Renaming the first function, Change the access modifier of the first function, Deletion of the first function, and The method according to claim 11, determined based on at least one of the modifications in the inheritance of the first function.

13. The second change described above is: Changing the count of the input parameters of the first function, Changing the default values ​​of one or more input parameters of the first function, Changing the data type of one or more input parameters of the first function, Changing the names of one or more input parameters of the first function, and The method according to claim 11, determined based on at least one of the changes in the order of the one or more input parameters.

14. The third change described above is: Changing the count of one or more output parameters of the first function, Changing the data type of one or more output parameters of the first function, Changing the names of one or more output parameters of the first function, and The method according to claim 11, determined based on at least one of the changes in the order of the one or more output parameters.

15. Before receiving the aforementioned input, the extraction of the data set and the execution of the set of operations are performed, Based on the above implementation, the set of compatibility results is stored in the database, The method according to claim 1, further comprising querying the database based on the received input to generate the compatibility result.

16. The method according to claim 1, wherein the compatibility result indicates that one or more APIs or functions used in the source code of the software application are not backward compatible with the second version of the software.

17. The aforementioned support information is, A first recommendation for updating the source code of the software application to source code compatible with the second version of the software. A second recommendation to update to a third version of the software that is different from the first or second version of the software, and The method according to claim 1, further comprising one or more reasons for explaining the cause of backward incompatibility of one or more APIs or functions used in the source code of the software application with respect to the second version of the software.

18. One or more non-temporary computer-readable storage media configured to store instructions, wherein the instructions cause the system to perform an action in response to being executed, and the action is: Receiving input related to a software application, Based on the above input, One or more application programming interfaces (APIs) or functions used in the source code of the software application, and Determining first information about a first version of software that provides one or more APIs or functions, Based on the first information described above, extract a set of data from one or more web-based sources, wherein the set of data is: One or more changes in the source code of a second version of the software that is different from the first version of the software, and Extracting information including second information about one or more changes in the second version, The process involves performing a set of operations, including one or more pattern search operations, on the aforementioned data set to generate compatibility results. A non-temporary computer-readable storage medium, which includes controlling a display device based on the compatibility results to display support information about one or more APIs or functions used in the source code of the software application for a second version of the software.

19. It is a system, Includes a processor, the processor is Receiving input related to a software application, Based on the above input, One or more application programming interfaces (APIs) or functions used in the source code of the software application, and Determining first information about a first version of software that provides one or more APIs or functions, Based on the first information described above, extract a set of data from one or more web-based sources, wherein the set of data is: One or more changes in the source code of a second version of the software that is different from the first version of the software, and Extracting information including second information about one or more changes in the second version, The process involves performing a set of operations, including one or more pattern search operations, on the aforementioned data set to generate compatibility results. A system configured to control a display device based on the compatibility results to display support information about one or more APIs or functions used in the source code of the software application for a second version of the software.

Images