A computing device is provided that automatically assigns bugs or errors associated with an application program to one or more developers that are best suited to address the bug. The bugs may be detected either at runtime or during a build process. The assignment of a bug to any given developer is based on an analysis of the debug information contained in a log file generated for the application program, as well as the knowledge of which developers worked on the code particularly associated with the detected bug, and/or on the contents of a pre-defined list that associates developers with different parts of the application program.
|
1. A computer-implemented method comprising:
using a programmable processing circuit of a computer:
retrieving a log file from a memory circuit comprising debug information generated for an application program, wherein the debug information is generated during a build of the application program, or during runtime of the application program, and indicates logic in the application program that caused an error;
parsing the log file to obtain the debug information;
generating, from a list of developers stored in a memory of the computer, a data set specifying developers associated with the error based on the debug information, wherein generating the data set comprises:
determining whether the logic that caused the error was included in a plurality of files that are part of the application program; and
if the logic that caused the error was included in a plurality of files:
determining an identifier for each developer that modified at least one of the plurality of files comprising the logic; and
adding each identifier for each developer to the data set;
selecting, from the generated data set, a developer responsible for correcting the error based on the debug information; and
assigning the selected developer to the error in the application program.
8. A computing device comprising:
a user input/Output (I/O) interface configured to receive user input, and to provide output to the user;
a memory configured to store a list of developers; and
a programmable processing circuit configured to:
retrieve a log file comprising debug information generated for an application program, wherein the debug information is generated during a build of the application program, or during runtime of the application program, and indicates logic in the application program that caused an error;
parse the log file to obtain the debug information;
generate, from the list of developers, a data set specifying developers associated with the error based on the debug information, wherein to generate the data set the processing circuit is configured to:
determine whether the logic that caused the error was included in a plurality of files that are part of the application program; and
if the logic that caused the error was included in a plurality of files:
identify each developer that has modified at least one of the plurality of files comprising the logic; and
add an identifier for each developer to the data set;
selecting, from the data set, a developer responsible for correcting the error based on the debug information; and
assign the selected developer to the error in the application program.
15. A computer program product comprising a non-transitory computer readable storage medium comprising computer readable program code embodied therewith, wherein when executed by a processing circuit of a computing device, the computer readable program code controls the processing circuit to:
retrieve a log file comprising debug information generated for an application program, wherein the debug information is generated during a build of the application program, or during runtime of the application program, and indicates logic in the application program that caused an error;
parse the log file to obtain the debug information;
generate, from a list of developers stored in a memory, a data set specifying developers associated with the error based on the debug information wherein to generate the data set the computer readable program code controls the processing circuit to:
determine whether the logic that caused the error was included in a plurality of files that are part of the application program; and
if the logic that caused the error was included in a plurality of files:
identify each developer that has modified at least one of the plurality of files comprising the logic; and
add an identifier for each developer to the data set;
select, from the data set, a developer responsible for correcting the error based on the debug information; and
assign the selected developer to the error in the application program.
2. The method of
3. The method of
4. The method of
determining an identifier of the last developer to modify the file that comprises the logic; and
adding the identifier to the data set.
5. The method of
6. The method of
7. The method of
9. The computing device of
10. The computing device of
11. The computing device of
determine an identifier of the last developer to modify the file that comprises the logic; and
add the identifier to the data set.
12. The computing device of
13. The computing device of
14. The computing device of
16. The computer program product of
|
The present disclosure relates to computer systems, and more specifically, to systems and computer-implemented methods for assigning defects or bugs in software applications to a developer most appropriate to address and correct the defect.
Large software projects typically include the development of applications comprising many different types of files, such as source code and data files, for example. Generally, different software developers are responsible for different application functions, and thus, create and maintain their own files directed at performing or supporting those functions in a planned and structured development process. When completed, the different files are usually brought together in a build, for example, to create an executable application for distribution to end users.
During the development phase of the application, each developer can create and modify their particular files with little or no knowledge of the other developers or other parts of the application. However, during the build process, or even during runtime, errors can occur with the source code. When errors do occur, it is important to be able to quickly identify the developer or developers that are best suited to troubleshoot and/or correct the defect that caused the error. However, with so many different developers working on such diverse parts of an application, identifying the proper personnel to address an error is not always an easy and straightforward exercise.
The present disclosure provides a method and apparatus for automatically assigning bugs or errors associated with a software application to one or more developers that are best suited to address and/or correct the bug. Such bugs may, for example, be automatically detected either during a build process for the application, or during runtime of the application.
In both cases, a log file is generated that comprises debug information about an error or bug that is detected. The method and apparatus of the present disclosure analyzes log file and utilizes the information included in the log file, along with knowledge of which developers and development teams are responsible for which parts of the application, and generates a data set that specifies developers that are considered as candidates for addressing and/or correcting the error. From the data set, the method and apparatus selects a developer to be responsible for correcting the error and assigns the developer to the error.
Of course, those skilled in the art will appreciate that the present embodiments are not limited to the above contexts or examples, and will recognize additional features and advantages upon reading the following detailed description and upon viewing the accompanying drawings.
Aspects of the present disclosure are illustrated by way of example and are not limited by the accompanying figures with like references indicating like elements.
As will be appreciated by one skilled in the art, aspects of the present disclosure may be illustrated and described herein in any of a number of patentable classes or context including any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof. Accordingly, aspects of the present disclosure may be implemented entirely as hardware, entirely as software (including firmware, resident software, micro-code, etc.) or combining software and hardware implementation that may all generally be referred to herein as a “circuit,” “module,” “component,” or “system.” Furthermore, aspects of the present disclosure may take the form of a computer program product embodied in one or more computer readable media having computer readable program code embodied thereon.
Any combination of one or more computer readable media may be utilized. The computer readable media may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an appropriate optical fiber with a repeater, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable signal medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.
Computer program code for carrying out operations for aspects of the present disclosure may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Scala, Smalltalk, Eiffel, JADE, Emerald, C++, C#, VB.NET, Python or the like, conventional procedural programming languages, such as the “C” programming language, Visual Basic, Fortran 2003, Perl, COBOL 2002, PHP, ABAP, dynamic programming languages such as Python, Ruby and Groovy, or other programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider) or in a cloud computing environment or offered as a service such as a Software as a Service (SaaS).
Aspects of the present disclosure are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatuses (systems) and computer program products according to embodiments of the disclosure. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable instruction execution apparatus, create a mechanism for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
These computer program instructions may also be stored in a non-transitory computer readable medium that when executed can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions when stored in the computer readable medium produce an article of manufacture including instructions which when executed, cause a computer to implement the function/act specified in the flowchart and/or block diagram block or blocks. The computer program instructions may also be loaded onto a computer, other programmable instruction execution apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatuses or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
Accordingly, aspects of the present disclosure provide an apparatus and computer-implemented method for automatically assigning bugs detected in an application, either at runtime or during a build process, to one or more developers that are best suited to address the bug. The assignment of a bug to a given one or more developers may be based, for example, on an analysis of a log file generated by the application, as well as knowledge of which developers worked on the code particularly associated with the detected bug. With the present disclosure, the time needed to research and track a developer that is most appropriate to address and/or correct a detected bug is greatly reduced. So, too, is the complexity of the process of determining the appropriate developer or developers.
Referring now to the drawings,
As seen in
As seen in more detail later, each of these packages 12, 14, 16 may comprise one or more different files or different versions of the same file(s). Such files may include, by way of example only, source code files (e.g., .c, .cpp, .h, script files, etc.), object files, executable files, data files, image files, video files, and any other file that the application 10 utilizes to perform its functions. Different entities may organize and assign their developers to various parts or portions of the application 10 using different methodologies. However, as seen in the embodiment of
As described in more detail later, any of the developers in the development teams 18a-18d, as well as the lead developer 20, may be called upon to address and correct a bug or error, or other defect in the application 10. Further, it is generally most efficient to assign the developer or developers that are most familiar with the code to address and correct a detected bug. However, although possible, there is no requirement that any one developer be aware of the code and/or data in any given package other than his/her own. In fact, in instances where application 10 is a large, complicated application comprising many different packages and files, it is likely that any given developer will not be familiar with the code and/or data contained in any of the other packages. Therefore, it can be difficult to locate an appropriate developer having specific knowledge of the package 12, 14, 16 in which a bug is detected. In turn, time and resources are wasted on determining which of the plurality of developers should be assigned to research and correct a bug that is detected either during a build of the application 10 on a computing device, or during runtime of the application 10 on a computing device.
As previously stated, each package 12, 14, 16 includes one or more files labeled in
Periodically, all the packages 12, 14, 16 are brought together and undergo a software build process in which the source code in the packages 12, 14, 16 is processed and converted into executable code (i.e., application 10). There are many known processes for performing such builds; however, in one aspect of the present disclosure, the packages 12, 14, 16 are compiled into an executable application utilizing any of a plurality of well-known compilers.
Generally, if they occur, a compiler or other software application will detect errors during the build process. When an error is detected, the compiler or other application building the packages 12, 14, 16 will output information indicating the error to an error log file. The error log file can contain any type of information needed or desired, but in one embodiment, the error log file is a text file having multiple lines text identifying the date and time a given error occurred, the particular package having the source code associated with the error, the specific file, class, and line number of source code that caused the error, and a predetermined error code identifying the error and/or a short text description of the error. For example, the following line of text may be output to the error log to identify a BAD_OPERAND error detected on line 33 of the source file named “Access.cpp” during the build that occurred on Nov. 9, 2012.
[11/9/2012 16:54:33 Security Package Access.cpp Class:Access line:33 Code:432 BAD_OPERAND]
Of course, this line of text is included only for illustrative purposes. As those skilled in the art will appreciate, more or less information may be included in the error log file, and further, may be arranged in any manner known in the art.
As previously stated, conventional means of assigning a developer to correct the detected error or bug in the application is inefficient. More particularly, it requires a person to manually sift through the error log file(s), which in most cases are numerous and very lengthy, to identify the particular error(s) that occurred. Once identified, the person reviewing the error log has to determine which of the many developers associated with the application 10 would be the best developer to analyze, research, address, and correct the detected bug. With the present disclosure, however, the computing device executing the build process is configured to automatically analyze the error log file to determine whether an error occurred during the build process, and then cross-match the particular package and/or file in which the error occurred to the appropriate one or more developers responsible for addressing and/or correcting the detected bug.
As seen in
The device will then begin to generate the data set specifying the developers. Particularly, the device first determines which development team 18a-18d, if any, is assigned to the file or class associated with the error and adds the identities of those teams to the data set (box 34). As seen later, the identity of the development team(s) may be obtained from a database, for example, that associates each package, file in the package, and/or class within the file, with one or more of the development teams 18a-18d, or in some aspects, one or more particular developers. Such information may be automatically added to, removed from, and maintained in the database, whenever a developer checks code into and out of a common repository that stores the code, for example.
With any given bug or error detected during the build process, the developer that last modified the code producing or associated with the error is very likely to be the most knowledgeable developer to address and correct the error. Thus, according to one or more aspects of the present disclosure, the computing device executing the build process is configured to check the contents of the last successful build of the application to determine whether the package associated with the detected error was also part of the last build. If so, the device checks to determine whether that version of the package (i.e., from the last build) also contained the file or class associated with the detected error (box 36). If so (box 38), then the device determines that the developer associated with the current build is the last developer to have modified the file or class associated with the error, identifies that developer using the information stored in the database as previously stated, and adds an identifier associated with the developer to the data set or “pool” of developers. Further, because that particular developer was the last to have modified the file or class, he/she is considered to be the most knowledgeable or appropriate developer to address and correct the detected error. Therefore, according to one or more embodiments, that developer is also classified within the data set or “pool” as being the highest ranked responsible developer (box 40).
Additionally, any given file or class may also be utilized in other packages and/or modified by other developers. By way of example, files or classes having code common to more than one package may be part of multiple packages, which in turn, may be assigned to different developers. Therefore, the computing device performing the build will also check the other packages in the current build to determine whether the file or class associated with the error is used in at least one other package. If so, the device checks whether other developers modified the file or class since the last successful build (box 42). If the computing device determines that one or more other developers also modified the file or class, the computing device will identify those developers from the database as being knowledgeable developers to which the bug may be assigned and add their identities to the data set of developers (box 44).
Once the data set of developers has been identified and the developers classified as being either a highest ranked or a high ranked responsible developer, the computing device performing the build process assigns the responsibility of addressing and correcting the detected error or bug to one or more developers identified in the data set. The method considers different techniques for performing this function. For example, in one embodiment, the device performing the build process simply assigns the error or bug to whichever developer in the data set is indicated as being the highest ranked responsible developer. In another embodiment, the device assigns the error or bug to whichever developer was the last developer to have modified the package, file, or class. In other embodiments, the error or bug is assigned to an entire development team or a group of developers. In this embodiment, however, the device assigns the error or bug detected during the build process to a developer identified in the data set that is the highest ranked responsible developer who is also on the development team 18a-18d associated with the particular package associated with the error (box 46).
In some cases, there may be conflicts as to which developer is the best suited to address and correct the detected error. For example, analysis of the information contained in the error log may reveal that more than one developer from the same development team modified the file or class causing the detected error since the last successful build. In such cases, the computing device may simply assign the detected error to whichever developer was the last developer to modify the file or class within the identified package. Additionally, if for some reason the computing device cannot determine an appropriate developer for a given error, the computing device may simply assign the error to a default developer (e.g., lead developer 20 or some other specially designated developer), or to the entire development team associated with the specific package and/or file(s) that caused the error to occur (box 48).
Regardless of which developer or developers are assigned to address and correct the error, however, the computing device performing the build notifies the identified developer(s) via any means known in the art. For example, the device may automatically generate a bug report and email the report to:
Although useful, the present disclosure is not limited only to use during a build process. Rather, as seen in
With the timeline of
Method 60 begins with the computing device analyzing the error log to identify the particular error or errors that occurred during runtime of application 10, as well as the particular package, file, and/or class having the source code that caused the error (box 62). As previously stated, this may be performed by parsing the information in the error log and extracting predetermined information. The device then identifies the development team(s) 18a-18d, if any, that are assigned to the package containing the file/class and adds their corresponding identities to the data set or “pool”, as previously described (box 64). The method 60 then determines which developer was the last developer to have modified the file or class associated with the detected error. Particularly, the device is configured to check an immediate prior build of application 10 to determine whether the file or class associated with the detected error was previously part of application 10 (box 66). For example, referring to the timeline of
If the file or class associated with the detected error existed in the immediately previous build of application 10 (box 66), the computing device utilizes the database previously described to identify the developer associated with the package containing the file or class that caused the error and adds the identity of that developer to the data set (box 68). The device also classifies the identified developer as being a highest ranked responsible developer (i.e., the developer best suited to address the error) (box 70).
The device executing the application 10 then checks one or more previous build versions of application 10 for a predetermined prior time period (e.g., 3 weeks) to determine whether the file or class (e.g., FILE C) also appeared in the packages of those builds as well (box 72). As stated above, this will help the device to identify other developers that may have modified the file, class, or package associated with the detected error. By way of example, consider a scenario wherein the device has detected an error in FILE C during runtime, and in which the predetermined time period d-n is three weeks. As stated above, the device would check the GUI package 22, and then check the storage and platform packages 14, 16 that were modified and added to the build on day d-n because they fall within the predetermined three week time period. However, the device would not check the security package 12 as that particular package was not added to the application 10 or modified within the predetermined time period.
The device next identifies the developer(s) that modified or added the files or classes in the other packages and adds their identities to the data set (box 74), and classifies each of these identified developers as being a high ranked responsible developer (box 76). Based on the developers identified in the data set, the device then classifies the developer who was last to modify the file or class as a highest ranked responsible developer (box 78), and assigns the detected error to the developer having the highest ranking and who is a member of the development team associated with the package (box 80).
As above, there may be conflicts as to which developer is the best suited to address and correct the detected error. In such cases, the computing device may assign the error to a default developer (e.g., lead developer 20), to the entire development team associated with the specific package and/or file(s) that caused the error to occur, or to some other developer (box 82). The device then notifies the responsible developer(s) as previously described (box 84).
As seen in
The user I/O interface 94 provides the components necessary for a user to interact with the device 90. Such components include, but are not limited to, a display 96 and a keyboard 98 that allows a user to interact with application 10, as well as the monitor application 106 during the build and runtime processes. For example, the monitor application 106 may output certain information regarding the detected errors or bugs, as well as the identified developer(s) and team(s), to the display for the user.
The memory 100 may comprise any non-transitory, solid state memory or computer readable media known in the art. Suitable examples of such media include, but are not limited to, ROM, DRAM, Flash, or a device capable of reading computer-readable media, such as optical or magnetic media. The memory 100 stores programs and instructions, such as application 10, a compiler 102, and the monitor application 106 that may be executed by controller 92. The compiler 102, when executed by controller 92, compiles source code into application 10 and outputs an error log 104 to identify any errors that occur during the build process. The application 10, as stated previously, also outputs an error log file 104 to indicate errors or bugs that occur during runtime. The monitor application 106, when executed by device 90, causes the programmable controller 92 to automatically analyze the debug information contained in the error log 104 associated with the application 10, and to assign any bugs or errors detected from analyzing the debug information in the error log file 104 to one or more developers best suited to address the bug or error. As stated previously, the monitor application 106 may have access to a database (DB) that associates the different packages, files, and or classes that comprise application 10 to one or more developers or development teams. In operation, the monitor application 106 can access this DB to obtain information based on the data extracted from error log 104.
The communications interface 108 comprises a transceiver or other communications interface known in the art that facilitates the communications with one or more remote parties over a communications network. Such an interface may comprise, for example, an ETHERNET component capable of communicating data and information over a communications network as is known in the art. In one aspect, the controller 92, in accordance with the instructions in the monitor application 106, generates emails or other messages to one or more developers identified by the monitor application to inform them of their assignment to a given bug or error in application 10.
The present embodiments may, of course, be carried out in other ways than those specifically set forth herein without departing from essential characteristics of the disclosure. For example, it should be noted that the flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various aspects of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The terminology used herein is for the purpose of describing particular aspects only and is not intended to be limiting of the disclosure. As used herein, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.
The corresponding structures, materials, acts, and equivalents of any means or step plus function elements in the claims below are intended to include any disclosed structure, material, or act for performing the function in combination with other claimed elements as specifically claimed. The description of the present disclosure has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the disclosure in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the disclosure. The aspects of the disclosure herein were chosen and described in order to best explain the principles of the disclosure and the practical application, and to enable others of ordinary skill in the art to understand the disclosure with various modifications as are suited to the particular use contemplated.
Thus, the foregoing description and the accompanying drawings represent non-limiting examples of the methods and apparatus taught herein. As such, the present invention is not limited by the foregoing description and accompanying drawings. Instead, the present invention is limited only by the following claims and their legal equivalents.
Patent | Priority | Assignee | Title |
10192177, | Jun 29 2016 | Microsoft Technology Licensing, LLC | Automated assignment of errors in deployed code |
10248919, | Sep 21 2016 | Red Hat Israel, Ltd. | Task assignment using machine learning and information retrieval |
10331541, | Jun 14 2016 | Open Invention Network LLC | Collaborative data sharing and data modification application |
10754640, | Mar 24 2017 | Microsoft Technology Licensing, LLC | Engineering system robustness using bug data |
10860312, | Jan 27 2017 | INTUIT, INC. | Defect ownership assignment system and predictive analysis for codebases |
10970636, | Jan 26 2017 | INTUIT INC. | Adaptive system for predicting integration failures in large systems |
11063946, | Oct 24 2018 | ServiceNow, Inc. | Feedback framework |
11281457, | Aug 16 2017 | Amazon Technologies, Inc. | Deployment of infrastructure in pipelines |
11288592, | Mar 24 2017 | Microsoft Technology Licensing, LLC | Bug categorization and team boundary inference via automated bug detection |
11301356, | May 28 2019 | APIIRO LTD. | System, method, and process for continuously identifying material changes and calculating risk for applications and infrastructure |
11537502, | Nov 19 2021 | Bank of America Corporation | Dynamic system for active detection and mitigation of anomalies in program code construction interfaces |
11556444, | Nov 19 2021 | Bank of America Corporation | Electronic system for static program code analysis and detection of architectural flaws |
11700255, | Oct 24 2018 | ServiceNow, Inc. | Feedback framework |
11803429, | Oct 30 2020 | Red Hat, Inc. | Managing alert messages for applications and access permissions |
9898280, | Jan 05 2013 | VMware LLC | Automatic code review and code reviewer recommendation |
Patent | Priority | Assignee | Title |
8271952, | Nov 14 2003 | CALLAHAN CELLULAR L L C | Aggregation and prioritization of application issue data |
8627308, | Jun 30 2010 | SNAPCHAT, INC | Integrated exchange of development tool console data |
8832659, | Dec 06 2010 | University of Washington Through Its Center for Commercialization | Systems and methods for finding concurrency errors |
8972954, | Jul 13 2009 | Adobe Inc | Debugging method using program inspectors to debug programs developed using frameworks and libraries |
20100211932, | |||
20150355998, | |||
WO2014120192, |
Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
Mar 06 2013 | CA, Inc. | (assignment on the face of the patent) | / | |||
Mar 06 2013 | ZLATNIK, PAVEL | CA, INC | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 029943 | /0258 |
Date | Maintenance Fee Events |
Mar 08 2017 | ASPN: Payor Number Assigned. |
Dec 07 2020 | REM: Maintenance Fee Reminder Mailed. |
May 24 2021 | EXP: Patent Expired for Failure to Pay Maintenance Fees. |
Date | Maintenance Schedule |
Apr 18 2020 | 4 years fee payment window open |
Oct 18 2020 | 6 months grace period start (w surcharge) |
Apr 18 2021 | patent expiry (for year 4) |
Apr 18 2023 | 2 years to revive unintentionally abandoned end. (for year 4) |
Apr 18 2024 | 8 years fee payment window open |
Oct 18 2024 | 6 months grace period start (w surcharge) |
Apr 18 2025 | patent expiry (for year 8) |
Apr 18 2027 | 2 years to revive unintentionally abandoned end. (for year 8) |
Apr 18 2028 | 12 years fee payment window open |
Oct 18 2028 | 6 months grace period start (w surcharge) |
Apr 18 2029 | patent expiry (for year 12) |
Apr 18 2031 | 2 years to revive unintentionally abandoned end. (for year 12) |