CROSS-REFERENCE TO RELATED APPLICATIONS AND PRIORITY
[001] The present application does not claim priority from any patent application.
TECHNICAL FIELD
[002] The present disclosure in general relates to the field of a software development cycle. More particularly, the present invention relates to a system and method for transmitting an alert during a software development cycle.
BACKGROUND
[003] In a software development cycle, after a software application is developed, a software code of the software application, written by a developer, is executed. During the execution of the code, one or more errors, associated with the code, are identified. Currently, the developer has to locate the one or more errors manually and make changes in the code to resolve the one or more errors. Also, once the one or more errors are resolved, the code has to be again executed from beginning. The process of locating the one or more errors manually and executing the code from the beginning is a time consuming process. Further, some of run time error detection techniques are available to detect an error in the code. However, these run time error detection techniques fails to extract a cause of the error and other relevant information at the time of coding. Thus, the developer may have to again spend time to identify the cause of the error and to resolve the error.
[004] Further, if the same error occurs in an another code block, then the developer has to again spend time to identify the cause of the error. Hence, it may be understood that the current technology requires a lot of manual intervention and is a time consuming process.
SUMMARY
[005] Before the present systems and methods for transmitting an alert during a software development cycle, is described, it is to be understood that this application is not limited to the particular systems, and methodologies described, as there can be multiple possible embodiments which are not expressly illustrated in the present disclosure. It is also to be understood that the terminology used in the description is for the purpose of describing
3
the particular versions or embodiments only, and is not intended to limit the scope of the present application. This summary is provided to introduce concepts related to systems and method for transmitting the alert during the software development cycle. This summary is not intended to identify essential features of the claimed subject matter nor is it intended for use in determining or limiting the scope of the claimed subject matter.
[006] In one implementation, a method for transmitting an alert during a software development cycle is illustrated. In one embodiment, the method may comprise storing a set of issues in a repository. Each issue, from the set of issues, may be associated with at least one function from a set of functions. The set of functions may be used in the software development cycle. Further, the method may comprise identifying a target function used by a user in a target module, during the software development cycle. Once the target function is identified, the method may comprise extracting a subset of issues, associated with the target function, from the repository. Further, the method may comprise determining a priority of each issue, from the subset of issues. In one embodiment, the priority may be based on at least one of a frequency of occurrence of issue and a severity of issue in the software development cycle. The frequency of issue and the severity of issue may be based on weightage of the target module in the software development cycle. Upon determining the priority of issue, the method may comprise transmitting an alert to the user, during the software development cycle, thereby assisting the user during the software development cycle. In one aspect, the alert may correspond to one or more issues, from the subset of issues, based on the priority.
[007] In another implementation, a system for transmitting an alert during a software development cycle is illustrated. The system comprises a memory and a processor coupled to the memory, further the processor is configured to execute programmed instructions stored in the memory. In one embodiment, the processor may execute programmed instructions stored in the memory for storing a set of issues in a repository. Each issue, from the set of issues, may be associated with at least one function from a set of functions. The set of functions may be used in the software development cycle. Further, the processor may execute programmed instructions stored in the memory for identifying a target function used by a user in a target module, during the software development cycle. Once the target function is identified, the processor may execute programmed instructions stored in the memory for extracting a subset of issues, associated with the target function, from
4
the repository. Further, the processor may execute programmed instructions stored in the memory for determining a priority of each issue, from the subset of issues. In one embodiment, the priority may be based on at least one of a frequency of occurrence of issue and a severity of issue in the software development cycle. The frequency of issue and the severity of issue may be based on weightage of the target module in the software development cycle. Upon determining the priority of issue, the processor may execute a programmed instruction for transmitting an alert to the user, during the software development cycle, thereby assisting the user during the software development cycle. In one aspect, the alert may correspond to one or more issues, from the subset of issues, based on the priority.
[008] In yet another implementation, a computer program product having embodied computer program for transmitting an alert during a software development cycle is disclosed. In one embodiment, the program may comprise a program code for storing a set of issues in a repository. Each issue, from the set of issues, may be associated with at least one function from a set of functions. The set of functions may be used in the software development cycle. Further, the program may comprise a program code for identifying a target function used by a user in a target module during the software development cycle. Once the target function is identified, the program may comprise a program code for extracting a subset of issues, associated with the target function, from the repository. Further, the program may comprise a program code for determining a priority of each issue, from the subset of issues. In one embodiment, the priority may be based on at least one of a frequency of occurrence of issue and a severity of issue in the software development cycle. The frequency of issue and the severity of issue may be based on weightage of the target module in the software development cycle. Upon determining the priority of issue, the processor may comprise a program instruction for transmitting an alert to the user, during the software development cycle, thereby assisting the user during the software development cycle. In one aspect, the alert may correspond to one or more issues, from the subset of issues, based on the priority.
BRIEF DESCRIPTION OF DRAWINGS
[009] The detailed description is described with reference to the accompanying figures. In the figures, the left-most digit(s) of a reference number identifies the figure in
5
which the reference number first appears. The same numbers are used throughout the drawings to refer like features and components.
[0010] Figure 1 illustrates a network implementation of a system for transmitting an alert during a software development cycle, in accordance with an embodiment of the present subject matter.
[0011] Figure 2 illustrates the system for transmitting an alert during a software development cycle, in accordance with an embodiment of the present subject matter.
[0012] Figure 3 illustrates a method for transmitting an alert during a software development cycle, in accordance with an embodiment of the present subject matter.
DETAILED DESCRIPTION
[0013] Some embodiments of the present disclosure, illustrating all its features, will now be discussed in detail. The words “storing”, “identifying”, “extracting”, “determining”, “transmitting” and other forms thereof, are intended to be equivalent in meaning and be open ended in that an item or items following any one of these words is not meant to be an exhaustive listing of such item or items, or meant to be limited to only the listed item or items. It must also be noted that as used herein and in the appended claims, the singular forms "a", "an" and "the" include plural references unless the context clearly dictates otherwise. Although any systems and methods similar or equivalent to those described herein can be used in the practice or testing of embodiments of the present disclosure, the exemplary, systems and methods for transmitting an alert during a software development cycle are now described. The disclosed embodiments of the system and method for transmitting the alert during the software development cycle are merely exemplary of the disclosure, which may be embodied in various forms.
[0014] Various modifications to the embodiment will be readily apparent to those skilled in the art and the generic principles herein may be applied to other embodiments. However, one of ordinary skill in the art will readily recognize that the present disclosure for transmitting an alert during a software development cycle is not intended to be limited to the embodiments illustrated, but is to be accorded the widest scope consistent with the principles and features described herein.
6
[0015] The present subject matter relates to transmitting an alert during a software development cycle. In one embodiment, a set of issues, associated with at least one function from a set of functions, may be stored in a repository. The set of functions may be used, by a user, in the software development cycle. In one aspect, the repository may be configured to store data. The data may correspond to the set of issues, the set of functions associated with issue, an issue cause, a module name associated with issue, a submodule name associated with issue, a class name associated with issue, a platform associated with issue, a file name associated with issue, a language associated with software development cycle, stack traces ad other parameters. Further, one or more inputs may be received, from a user, during the software development cycle. Based on the one or more inputs, a target function, used by the user in a target module, may be identified. Once the target function is identified, a subset of issues, associated with the target issue, may be extracted from the repository. Further, a priority of each issue, from the subset of issues, may be determined. The priority may be based on at least one of a frequency of occurrence of issue and a severity of issue. Based on the priority, an alert may be transmitted to the user, during the software development cycle. In one aspect, the alert may correspond to one or more issues, from the subset of issues. Further, the network implementation of system for transmitting an alert during a software development cycle is illustrated with Figure 1.
[0016] Referring now to Figure 1, a network implementation 100 of a system 102 for transmitting an alert during a software development cycle is disclosed. Although the present subject matter is explained considering that the system 102 is implemented on a server, it may be understood that the system 102 may also be implemented in a variety of computing systems, such as a laptop computer, a desktop computer, a notebook, a workstation, a mainframe computer, a server, a network server, and the like. In one implementation, the system 102 may be implemented over a cloud network. Further, it will be understood that the system 102 may be accessed by multiple users through one or more user devices 104-1, 104-2…104-N, collectively referred to as user device 104 hereinafter, or applications residing on the user device 104. Examples of the user device 104 may include, but are not limited to, a portable computer, a personal digital assistant, a handheld device, and a workstation. The user device 104 may be communicatively coupled to the system 102 through a network 106.
7
[0017] In one implementation, the network 106 may be a wireless network, a wired network or a combination thereof. The network 106 may be implemented as one of the different types of networks, such as intranet, local area network (LAN), wide area network (WAN), the internet, and the like. The network 106 may either be a dedicated network or a shared network. The shared network represents an association of the different types of networks that use a variety of protocols, for example, Hypertext Transfer Protocol (HTTP), Transmission Control Protocol/Internet Protocol (TCP/IP), Wireless Application Protocol (WAP), and the like, to communicate with one another. Further, the network 106 may include a variety of network devices, including routers, bridges, servers, computing devices, storage devices, and the like.
[0018] In one embodiment, the system 102 may be configured to store a set of issues in a repository. Each issue, from the set of issues, may be associated with at least one function, from a set of function. The set of functions may be used, by a user in different modules, in the software development cycle. In one aspect, the repository may be further configured to store data. The data may correspond to the set of issues, the set of functions, an issue cause, a module name associated with issue, a submodule name associated with issue, a class name associated with issue, a platform associated with issue, a file name associated with issue, a language associated with the software development cycle, a stack traces, other parameters and the like. Further, the system 102 may be configured to compute a severity of issue and a priority of issue. The system 102 may be configured to use a triage process to compute the severity of issue and the priority of the issue. In one aspect, the severity of issue may be stored in the repository.
[0019] Further, the system 102 may be configured to receive one or more inputs, from the user, during the software development cycle. Based on the one or more inputs, the system 102 may be configured to identify a target function used, by the user in a target module, during the software development cycle.
[0020] Upon identifying the target function, the system 102 may be configured to extract a subset of issues, associated with the target function, from the repository. In one example, the subset of issues may be extracted based on the target function, the target module, and other parameters stored in the repository.
8
[0021] Once the subset of issues is extracted, the system 102 may be configured to compute a frequency of occurrence of each issue, from the subset of issues. In one aspect, the frequency of occurrence may correspond to number of times the issue is present in the subset of issues. Further, the subset of issue may be sorted based on the frequency of occurrence of issue. Further, the system 102 may be configured to determine the priority of issue, from the subset of issues, based on at least one of the frequency of occurrence and the severity of issue. The system 102 may further compare the priority of issue, associated with the subset of issues, with a predefined threshold priority.
[0022] Further, the system 102 may identify one or more issues, from the subset of issues, based on the comparison of the priority of issue and the predefined threshold priority. Furthermore, the system 102 may transmit the alert to the user, during the software development cycle. The alert may correspond to the one or more issues, from the subset of issues, associated with the target function. In one aspect, the alert may correspond to a tooltip, associated with the target function, during the software development cycle. Further, the system for transmitting an alert during the software development cycle is elaborated with respect to figure 2.
[0023] Referring now to figure 2, the system 102 for transmitting an alert during a software development cycle is illustrated in accordance with an embodiment of the present subject matter. In one embodiment, the system 102 may include at least one processor 202, an input/output (I/O) interface 204, and a memory 206. The at least one processor 202 may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, state machines, logic circuitries, and/or any devices that manipulate signals based on operational instructions. Among other capabilities, at least one processor 202 may be configured to fetch and execute computer-readable instructions stored in the memory 206.
[0024] The I/O interface 204 may include a variety of software and hardware interfaces, for example, a web interface, a graphical user interface, and the like. The I/O interface 204 may allow the system 102 to interact with the user directly or through the user device 104. Further, the I/O interface 204 may enable the system 102 to communicate with other computing devices, such as web servers and external data servers (not shown). The I/O interface 204 may facilitate multiple communications within a wide variety of networks and protocol types, including wired networks, for example, LAN, cable, etc., and wireless
9
networks, such as WLAN, cellular, or satellite. The I/O interface 204 may include one or more ports for connecting a number of devices to one another or to another server.
[0025] The memory 206 may include any computer-readable medium known in the art including, for example, volatile memory, such as static random access memory (SRAM) and dynamic random access memory (DRAM), and/or non-volatile memory, such as read only memory (ROM), erasable programmable ROM, flash memories, hard disks, optical disks, and magnetic tapes. The memory 206 may include modules 208 and data 210.
[0026] The modules 208 may include routines, programs, objects, components, data structures, and the like, which perform particular tasks, functions or implement particular abstract data types. In one implementation, the module 208 may include data storage module 212, an identification module 214, an extraction module 216, a determination module 218, an alert transmission module 220, and other modules 222. The other modules 222 may include programs or coded instructions that supplement applications and functions of the system 102.
[0027] The data 210, amongst other things, serve as a repository for storing data processed, received, and generated by one or more of the modules 208. The data 210 may also include a repository 224, and other data 226. In one embodiment, the other data 226 may include data generated as a result of the execution of one or more modules in the other modules 222.
[0028] In one implementation, a user may access the system 102 via the I/O interface 204. The user may be registered using the I/O interface 204 in order to use the system 102. In one aspect, the user may access the I/O interface 204 of the system 102 for obtaining information, providing input information or configuring the system 102.
[0029] In one embodiment, the data storage module 212 may be configured to store a set of issues in a repository. Each issue, from the set of issues, may be associated with at least one function, from the set of functions. The set of functions may be used in different modules in the software development cycle. In one embodiment, the repository may be further configured to store data, associated with the set of issues. In one example, the data may correspond to historic data, associated with the set of issues. The data may correspond to the set of issues, the set of functions, an issue cause, a module name associated with issue, a submodule name associated with issue, a class name associated with issue, a
10
platform associated with issue, a file name associated with issue, a language associated with the software development cycle, a stack traces and other parameters. In one aspect, the data may be stored in the repository in a form of table.
[0030] In one exemplary embodiment, table 1 may further illustrate the storage of the data in the repository.
Table 1: Data stored in repository
Module name
Sub module name
location
Function
class
Env
StackTraces
Platform
Language
FileName
FileLocation
Parameters
Login
Login Authorization
USA
FOpen()
FileHandling
Win 2K8
0x..879
.net
C#
…FilEntry.Cs
…C:\TestLibFileName:”ABC.txt”, Location:C:\AbcProAccount
Account payable
India
X.ToString()
String
Win 7
0x..457
.net
C#
…StringHandler.Cs
--C:\StringsProgTextval:”””
[0031] Referring to table 1, the data may be stored in a form of table in the repository. In one embodiment, the data storage module 212 may be configured to store an issue, associated with the function “fopen()”. In this case, the data storage module 212 may be configured to store the module name as login, the submodule name as login authorization, the location as USA, the class name as FileHandling, the environment as Win 2K8, the stacktraces as 0x..879, the platform as .net, the language as C#, the file name as “…FilEntry.Cs”, the file location as “…C:\TestLib\” and other parameters. Similarly, the storing module 212 may be configured to store an issue associated with the function “X.Tostring()”. In this case, the data storage module 212 may be configured to store the module name as Account, the submodule name as account payable, the location as India, the class name as String, the environment as Win 7, the stacktraces as 0x..457, the platform
11
as .net, the language as C#, the file name as “…StringHandler.Cs”, the file location as “--C:\StringsProg\” and other parameters.
[0032] Once the data is stored in the repository, the data storage module 212 may be configured to determine a severity of each issue, from the set of issues. Further, the data storage module 212 may be configured to determine a priority of issue, from the sub of issues, based on the severity of issue. In one aspect, the data storage module 212 may use a triage process to determine the severity of issue and the priority of issue. In one example, the priority of issue is higher, if the severity of issue is high i.e. the issue is critical. In another example, the priority of issue is less, if the severity of issue is less i.e. the issue is trivial.
[0033] In one embodiment, the data storage module 212 may determine the severity of issue based on weightage of a target module in the software development cycle. In one aspect, the weightage of the target module, in the software development cycle, may be predefined. In one embodiment, if the weightage of the module is higher, then the severity of the issue may be high, and thus the priority of the issue may be high. In another embodiment, if the weightage of the module is less, then the severity of issue may be less, and thus the priority of the issue may be less. In one aspect, the severity of issue and the priority of issue may be determined based on an impact of the issue on the software development cycle. Further, the data storage module 212 may be configured to store the severity of issue in the repository.
[0034] In one exemplary embodiment, consider determining the severity of issue referring to the table 2, table 3, and table 4.
Table 2: Percentage to Severity
%age to Severity
Range
Severity
70-100
1
50-70
2
30-50
3
12
10-30
4
[0035] Referring to the table 2, if range of weightage varies between 70 to 100, then the severity of the issue is 1. Further, if range of weightage varies between 50 to 70, then the severity of the issue is 2. Furthermore, if range of weightage varies between 30 to 50, then the severity of issue is 3. Furthermore, if range of weightage varies between 10 to 30, then the severity of issue is 4. Further, if the severity of issue is 1, then the issue is critical as compared to an issue with the severity 4.
Table 3: Module Weightage
Module Weightage
Module Name
Weight%
Accounting
10
Login
20
Material
35
User defined parameter
35
[0036] Referring now to table 3, a set of modules, associated with the software development cycle, may comprise an accounting module, a login module, a material module, a user defined module. Further, a weightage of accounting module may be 10, the weightage of login module may be 20, the weightage of material module may be 35, and the weightage of user defined parameter may be 35.
Table 4: Submodule Weightage
Sub module Weightage
Sub module Name
Weight%
Account Receivable
32
Account Payable
22
13
Login Authorization
12
Login Authentication
12
User defined parameter
13
[0037] Referring now to table 4, a set of submodules, associated with the software development cycle, may comprise an account receivable module, an account payable module, a login authorization module, a login authentication module and user predefined parameter. Further, a weightage of account receivable module may be 32, the weightage of account payable module may be 22, the weightage of login authorization module may be 12, the weightage of login authentication module may be 12, and the weightage of user defined parameter may be 13.
[0038] Further, consider use of function ‘fopen()’ in the submodule account payable of the module accounting, in the software development cycle. The total weightage, of the module, may be an addition of the weightage of the submodule (22) and the weightage of the module (10). Thus, the total weightage may be 32. Thus, the severity of an issue, associated with the function ‘fopen()’ in the submodule account payable of the accounting module may be 3.
[0039] Further, the identification module 214 may be configured to identify a target function, used by the user, in a target module. The target function may be used by the user during the software development cycle. In one embodiment, the target module may be associated with the software development cycle. In one aspect, the identification module 214 may receive one or more inputs, from the user, during the software development cycle. Based on the one or more inputs, the identification module 214 may identify the target function. In one example, the one or more inputs may be received from the user while writing a software code, in the software development cycle. In one example, the identification module 214 may identify the target function based on recording one or more key press on a console.
[0040] In one exemplary embodiment, consider the target function as ‘fopen()’. In this case, the identification module 212 may record a text before an opening bracket ‘(’. Based
14
on analysing the text, the identification module 212 may identify the target function, during the software development cycle.
[0041] Once the target function is identified, the extraction module 216 may be configured to extract a subset of issues, associated with the target function. The subset of issues may be extracted from the repository. In one embodiment, the subset of issues may be identified based on the target function, the target module and the like. In another embodiment, the subset of issues may be extracted using one or more analytics algorithm. In one aspect, the extraction module 216 may also extract the module name, the submodule name, the class name and the like, associated with each issue, from the subset of issues.
[0042] Upon extracting the subset of issues, the determination module 218 may be configured to determine a frequency of occurrence of each issue, from the subset of issues. In one embodiment, the frequency of occurrence may correspond to number of times the issue is present in the subset of issues. In one exemplary embodiment, if an issue is present in the subset of issues for 3 times, then the frequency of occurrence of the issue may be 3. Further, the determination module 218 may be configured to group the issues based on the frequency of occurrence of issues. In one example, the determination module 218 may be configured to generate a table. The table may be configured to store the subset of issues along with the frequency of occurrence of issues. In one example, the issues, from the subset of issues, with high frequency of occurrence, may be stored at top of the table. In another example, the issues, from the subset of issues, with less frequency of occurrence may be stored at bottom of the table.
[0043] Further, the determination module 218 may be configured to sort the subset of issues based on the severity of issue, after the grouping of issues based on the frequency of occurrence. In one aspect, the determination module 218 may analyse the severity of issues, stored in the repository, to sort the subset of issues. In one example, the issues with high severity may be stored at the top of the table. In another example, the issues with less severity may be stored at the bottom of the table.
[0044] Furthermore, the determination module 218 may be configured to determine the priority of each issue, from the subset of issue. In one aspect, the priority of issue may be determined based on at least one of the frequency of occurrence of issue and the severity of issue. In one embodiment, the determination module 218 may be configured to use the
15
triage process to determine the priority of issue based on the severity of issue. In one example, if the severity of the issue is high, then the priority of the issue is high. In another embodiment, if the severity of issue is less, then the priority of issue is less.
[0045] Upon determining the priority of issue, the determination module 218 may be configured to compare the priority of each issue, from the subset of issues, with a predefined threshold priority. Based on the comparison, the determination module 218 may identify one or more issues, from the subset of issues. In one aspect, the one or more issues may correspond to issues with priority greater than the predefined threshold priority. In one example, the one or more issues may have high impact on the software development cycle.
[0046] Once the one or more issues are identified, the alert transmission module 220 may be configured to transmit an alert to the user, during the software development cycle. The alert may correspond to the one or more issues, associated with the target function. In one example, the user may identify the issue cause, based on the alert, and may find solution to resolve the issue.
[0047] In one embodiment, the alert may be in a form of a tooltip, associated with the target function. The tooltip may be configured to display the one or more issues, associated with the target function, to the user. In one example, the tooltip may also indicate the issue cause, associated with the one or more issues, to the user. In one aspect, the tooltip may correspond to a warning to the user regarding the one or more issues that may occur during the software development cycle. In one example, the tooltip may display the one or more issues to the user, when the user hovers a mouse over the target function.
[0048] Further, the alert transmission module 220 may be configured to generate a report. In one embodiment, the report may comprise the one or more issues, the target function, the severity of issue, the stack traces location, and an impact of issue on the software development cycle.
[0049] Exemplary embodiments discussed above may provide certain advantages. Though not required to practice aspects of the disclosure, these advantages may include those provided by the following features.
[0050] Some embodiments of the system and the method is configured to enhance a coder performance, by providing suggestions to the coder during coding.
16
[0051] Some embodiments of the system and the method is configured to generate an alert associated with probable issues during coding.
[0052] Some embodiments of the system and the method is configured to assist the user during the software development cycle.
[0053] Referring now to figure 3, a method 300 for transmitting an alert during a software development cycle, is disclosed in accordance with an embodiment of the present subject matter. The method 300 may be described in the general context of computer executable instructions. Generally, computer executable instructions can include routines, programs, objects, components, data structures, procedures, modules, functions, and the like, that perform particular functions or implement particular abstract data types. The method 300 may also be practiced in a distributed computing environment where functions are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, computer executable instructions may be located in both local and remote computer storage media, including memory storage devices.
[0054] The order in which the method 300 is described is not intended to be construed as a limitation, and any number of the described method blocks can be combined in any order to implement the method 300 or alternate methods. Additionally, individual blocks may be deleted from the method 300 without departing from the spirit and scope of the subject matter described herein. Furthermore, the method 300 can be implemented in any suitable hardware, software, firmware, or combination thereof. However, for ease of explanation, in the embodiments described below, the method 300 may be considered to be implemented in the above described system 102.
[0055] At block 302, a set of issues may be stored in a repository. In one implementation, the data storage module 212 may be configured to store the set of issues in the repository. Each issue, from the set of issues, may be associated with at least one function from a set of functions. The set of functions may be used by a user in the software development cycle. Further, the repository may be configured to store data associated with the set of issues. In one aspect, the data may correspond to the set of issues, the set of function, an issue cause, a module name associated with issue, a submodule name associated with issue, a stack traces, a platform associated with issue, a file name associated
17
with issue, a language associated with the software development cycle, other parameters and the like.
[0056] At block 304, a target function, used by the user, may be identified. In one implementation, the identification module 214 may be configured to identify the target function. In one aspect the target function may be used by the user in a target module during the software development cycle.
[0057] At block 306, a subset of issues, associated with the target function, maybe extracted. In one implementation, the extraction module 216 may be configured to extract the subset of issues from the repository. In one example, the subset of issues may correspond to issues, associated with the target function, occurred during the software developed cycle in past.
[0058] At block 308, a priority of each issue, from the subset of issues, may be determined. In one implementation, the determination module 218 may be configured to determine the priority of each issue, from the subset of issues. In one aspect, the priority may be based on a frequency of occurrence of issue and a severity of issue, in the software development cycle. In one example, the severity of issue and the priority of issue may be based on weightage of the target module in the software development cycle.
[0059] At block 310, an alert may be transmitted to the user during the software development cycle. In one implementation, the alert transmission module 220 may be configured to transmit the alert to the user. In one aspect, the alert may correspond to one or more issues, from the subset of issues, associated with the target function. In one embodiment, the alert may correspond to a tooltip, associated with the target function.
[0060] Although implementations for systems and methods for transmitting an alert during a software development cycle have been described, it is to be understood that the appended claims are not necessarily limited to the specific features or methods described. Rather, the specific features and methods are disclosed as examples of implementations for transmitting the user during the software development cycle.

WE CLAIM:
1. A method for transmitting an alert during a software development cycle, the method comprises steps of:
storing, by a processor, a set of issues in a repository, wherein each issue, from the set of issues, is associated with at least one function from a set of functions, wherein the set of functions are used in a software development cycle;
identifying, by the processor, a target function used by a user in a target module during the software development cycle;
extracting, by the processor, a subset of issues associated with the target function, from the repository;
determining, by the processor, a priority of each issue from the subset of issues, wherein the priority is determined based on at least one of a frequency of occurrence of issue and a severity of issue in the software development cycle, wherein the frequency of occurrence of issue and the severity of issue is computed based on weightage of the target module in the software development cycle; and
transmitting, by the processor, an alert to the user, wherein the alert corresponds to one or more issues, from the subset of issues, based on the priority, thereby assisting the user during the software development cycle.
2. The method of claim 1, wherein the repository is configured to store data, wherein the data corresponds to the set of issues, the set of functions associated with issue, an issue cause, a module name associated with issue, a submodule name associated with issue, a class name associated with issue, a platform associated with issue, a file name associated with issue, a language associated with the software development cycle, a stack traces and other parameters.
3. The method of claim 1, wherein the severity of issue and the priority of issue is computed using a triage process, wherein the severity of issue and the priority of issue are stored in the repository, and wherein the severity of issue and the priority of issue is based on an impact of the issue on the software development cycle.
4. The method of claim 1, wherein the one or more issues are identified by comparing the priority of each issue, from the subset of issues, with a predefined threshold priority.
19
5. The method of claim 1, further comprises generating a report, wherein the report comprises the one or more issues, the target function, the issue cause, a stack trace location, the severity of issue, and an impact of issue on the software development cycle.
6. The method of claim 1, wherein the alert corresponds to a tooltip associated with the target function, and wherein the tooltip is configured to display the one or more issues to the user.
7. A system for transmitting an alert in a software development cycle, the system comprising:
a memory;
a processor coupled to the memory, wherein the processor is configured to execute programmed instructions stored in the memory to:
store a set of issues in a repository, wherein each issue, from the set of issues, is associated with at least one function from a set of functions, wherein the set of functions are used in a software development cycle;
identify a target function used by a user in a target module during the software development cycle;
extract a subset of issues associated with the target function, from the repository;
determine a priority of each issue from the subset of issues, wherein the priority is determined based on at least one of a frequency of occurrence of issue and a severity of issue in the software development cycle, wherein the frequency of occurrence of issue and the severity of issue is computed based on weightage of the target module in the software development cycle; and
transmit an alert to the user, wherein the alert corresponds to one or more issues, from the subset of issues, based on the priority, thereby assisting the user during the software development cycle.
8. The system of claim 7, wherein the repository is configured to store data, wherein the data corresponds to the set of issues, the set of functions associated with issue, an issue cause, a module name associated with issue, a submodule name associated with issue, a class name associated with issue, a platform associated with issue, a file name
20
associated with issue, a language associated with the software development cycle, a stack traces and other parameters.
9. The system of claim 7, wherein the severity of issue and the priority of issue is computed using a triage process, wherein the severity of issue and the priority of issue are stored in the repository, and wherein the severity of issue and the priority of issue is based on an impact of the issue on the software development cycle.
10. The system of claim 7, wherein the one or more issues are identified by comparing the priority of each issue, from the subset of issues, with a predefined threshold priority.
11. The system of claim 7, further comprises generating a report, wherein the report comprises the one or more issues, the target function, the issue cause, a stack trace location, the severity of issue, and an impact of issue on the software development cycle.
12. The system of claim 7, wherein the alert corresponds to a tooltip associated with the target function, and wherein the tooltip is configured to display the one or more issues to the user.
13. A computer program product having embodied thereon a computer program for transmitting an alert in a software development cycle, the computer program product comprises:
a program code for storing a set of issues in a repository, wherein each issue, from the set of issues, is associated with at least one function from a set of functions, wherein the set of functions are used in a software development cycle;
a program code for identifying a target function used by a user in a target module during the software development cycle;
a program code for extracting a subset of issues associated with the target function, from the repository;
a program code for determining a priority of each issue from the subset of issues, wherein the priority is determined based on at least one of a frequency of occurrence of issue and a severity of issue in the software development cycle, wherein the frequency
21
of occurrence of issue and the severity of issue is computed based on weightage of the target module in the software development cycle; and
a program code for transmitting an alert to the user, wherein the alert corresponds to one or more issues, from the subset of issues, based on the priority, thereby assisting the user during the software development cycle.