Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A method performed using at least one processor of a processor-based system, the method comprising: for each time period of a plurality of time periods, determining one or more intermediate relationships between one or more mappings for that time period and one or more attributes of a software program, the one or more mappings for each time period mapping one or more changes that occur with respect to one or more source code files of a plurality of source code files during the respective time period to one or more portions of a compiled representation of the software program that represent at least one risk for the software program during execution; and determining one or more likelihoods that one or more respective subsets of a plurality of factors are to interfere with execution of the software program based at least in part on the one or more intermediate relationships.
Software development and analysis. This invention addresses the problem of identifying and predicting potential risks in software execution. The method involves analyzing changes made to source code files over multiple time periods. For each time period, intermediate relationships are established. These relationships link changes within source code files to specific portions of the compiled software program. These compiled portions are identified as representing potential risks during execution. Furthermore, the method determines the likelihood of various factors interfering with the software program's execution. This likelihood calculation is based, at least in part, on the established intermediate relationships between source code changes and risky compiled code segments. The system uses a processor-based system to perform these determinations.
2. The method of claim 1 , further comprising: correlating the one or more intermediate relationships that correspond to a first time period of the plurality of time periods to the one or more intermediate relationships that correspond to a second time period of the plurality of time periods to provide one or more temporal relationships; wherein determining the one or more likelihoods comprises: determining the one or more likelihoods that the one or more respective subsets of the plurality of factors are to interfere with the execution of the software program further based at least in part on the one or more temporal relationships.
This invention relates to analyzing software execution interference by correlating temporal relationships between factors that may impact performance. The method involves identifying a plurality of factors that could interfere with software execution, such as system resource usage, environmental conditions, or external dependencies. These factors are grouped into subsets, and intermediate relationships between them are established for different time periods. The method then correlates these intermediate relationships across multiple time periods to derive temporal relationships, which indicate how factors interact over time. Using these temporal relationships, the method determines the likelihood that specific subsets of factors will interfere with software execution. The analysis considers both the direct relationships between factors and their evolving interactions over time, providing a more accurate assessment of potential performance issues. This approach helps in predicting and mitigating software execution disruptions by accounting for temporal dependencies between influencing factors.
3. The method of claim 1 , further comprising: correlating a specified change that occurs with respect to at least one specified source code file of the plurality of source code files during a designated time period of the plurality of time periods to at least one new functionality that is being added to the software program and that is addressed by the specified change to provide a specified correlation; wherein determining the one or more likelihoods comprises: determining the one or more likelihoods that the one or more respective subsets of the plurality of factors are to interfere with the execution of the software program further based at least in part on the specified correlation.
This invention relates to software development and the analysis of source code changes to assess their impact on software functionality. The problem addressed is the difficulty in predicting how changes to source code files may affect the execution of a software program, particularly when new functionalities are introduced. The solution involves correlating specific changes in source code files during designated time periods with the addition of new functionalities. By analyzing these correlations, the system determines the likelihood that subsets of factors—such as code modifications, dependencies, or execution conditions—will interfere with the software's execution. The method improves the accuracy of impact assessments by considering how changes relate to new features, helping developers anticipate potential issues before deployment. The approach integrates temporal analysis of code changes with functional context, providing a more nuanced understanding of how modifications may disrupt software behavior. This enhances software reliability and reduces the risk of unintended consequences from code updates.
4. The method of claim 1 , further comprising: correlating a specified change that occurs with respect to at least one specified source code file of the plurality of source code files during a designated time period of the plurality of time periods to at least one enhancement to an existing functionality of the software program that is addressed by the specified change to provide a specified correlation; wherein determining the one or more likelihoods comprises: determining the one or more likelihoods that the one or more respective subsets of the plurality of factors are to interfere with the execution of the software program further based at least in part on the specified correlation.
This invention relates to software development and maintenance, specifically to analyzing source code changes to assess their impact on software functionality and execution. The problem addressed is the difficulty in predicting how modifications to source code files may affect existing software features, leading to potential execution errors or unintended behavior. The method involves tracking changes made to source code files over multiple time periods and correlating these changes with enhancements or modifications to the software's functionality. By analyzing these correlations, the system determines the likelihood that specific subsets of factors—such as code modifications, dependencies, or environmental variables—will interfere with the software's execution. The correlation process links a particular change in a source code file to a specific improvement or alteration in the software's functionality, providing a basis for assessing risk. The system evaluates the likelihood of execution interference by considering these correlations alongside other factors, such as the nature of the change, its scope, and its interaction with other code components. This approach helps developers and maintainers anticipate potential issues before they arise, improving software reliability and reducing debugging efforts. The method is particularly useful in large-scale or complex software projects where changes can have far-reaching and unpredictable effects.
5. The method of claim 1 , comprising: for a designated time period of the plurality of time periods, determining a specified intermediate relationship between a designated mapping, which maps one or more designated changes that occur with respect to at least one source code file of the plurality of source code files during the designated time period to at least one portion of the compiled representation of the software program that includes a defect, and a developer who makes at least one of the one or more designated changes; wherein determining the one or more likelihoods comprises: determining the one or more likelihoods based at least in part on the specified intermediate relationship indicating that the defect is attributable to the developer who makes the at least one of the one or more designated changes.
This invention relates to software development and defect attribution, specifically identifying developers responsible for defects in compiled software programs. The problem addressed is the difficulty in tracing software defects back to the specific code changes and developers responsible, which is critical for efficient debugging and accountability. The method analyzes source code changes across multiple time periods to determine their impact on compiled software representations. For a given time period, it identifies changes made to source code files and maps these changes to portions of the compiled program where defects are detected. The method then establishes an intermediate relationship between these changes and the developers who made them. This relationship is used to calculate the likelihood that a particular developer is responsible for a defect, based on their contributions during the relevant time period. By correlating code changes with defects and developer activity, the system provides a probabilistic attribution of responsibility. This helps teams prioritize debugging efforts and improve code quality by linking defects to specific developers and their changes, enabling targeted improvements and accountability. The approach leverages temporal and code-level relationships to enhance defect tracing in software development workflows.
6. The method of claim 1 , wherein at least one mapping for each time period is associated with an extensible markup language (XML) schema.
This invention relates to data processing systems that manage time-based data mappings, particularly in environments requiring structured data representation. The problem addressed is the need for a flexible and standardized way to define and associate data mappings with specific time periods, ensuring compatibility with widely used data formats. The invention describes a method for managing data mappings over time, where each mapping is linked to a distinct time period. At least one mapping for each time period is associated with an Extensible Markup Language (XML) schema, which provides a structured framework for defining data elements and their relationships. This association ensures that the data mappings adhere to a predefined structure, enabling consistent data interpretation and interoperability across different systems. The method involves generating or updating mappings for each time period, where each mapping defines how data should be processed, transformed, or interpreted during that period. By associating these mappings with an XML schema, the system enforces a standardized format, reducing errors and improving data integrity. The XML schema may include rules for data validation, element definitions, and hierarchical relationships, ensuring that the mappings are both flexible and rigorously defined. This approach is particularly useful in applications where data requirements evolve over time, such as financial systems, regulatory compliance tracking, or dynamic configuration management. The use of XML schemas ensures that the mappings remain interpretable and maintainable, even as the underlying data structures or business rules change.
7. The method of claim 1 , further comprising: correlating the one or more source code files for each time period to one or more functions of the software program to provide one or more second correlations, each function corresponding to a respective sub-routine of the software program; wherein the one or more mappings for each time period is based at least in part on the one or more second correlations.
This invention relates to software analysis, specifically tracking changes in source code files over time and correlating them with software program functions. The problem addressed is the difficulty in understanding how modifications to source code files impact specific functions or sub-routines within a software program, particularly in large or complex systems where changes may be distributed across multiple files. The method involves analyzing source code files over multiple time periods to identify changes. These changes are then correlated with specific functions of the software program, where each function corresponds to a sub-routine. The correlations between source code files and functions are used to generate mappings for each time period, allowing developers to trace how code modifications affect individual functions. This helps in debugging, maintenance, and understanding the evolution of software behavior over time. The approach improves upon prior methods by providing a more granular and accurate way to link source code changes to specific functions, rather than treating the entire codebase as a monolithic entity. This is particularly useful in collaborative environments where multiple developers may work on different parts of the code simultaneously. The mappings generated can be used to track dependencies, identify potential issues, and ensure that changes do not inadvertently disrupt other parts of the software.
8. A system comprising: memory; and one or more processors coupled to the memory and configured to: for each time period of a plurality of time periods, determine one or more intermediate relationships between one or more mappings for that time period and one or more attributes of a software program, the one or more mappings for each time period mapping one or more changes that occur with respect to one or more source code files of a plurality of source code files during the respective time period to one or more portions of a compiled representation of the software program that represent at least one risk for the software program during execution; and determine one or more likelihoods that one or more respective subsets of a plurality of factors are to interfere with execution of the software program based at least in part on the one or more intermediate relationships.
This system operates in the domain of software risk assessment and monitoring, addressing the challenge of identifying and quantifying potential risks in software execution by analyzing changes in source code and their impact on compiled representations. The system tracks modifications to source code files over multiple time periods and maps these changes to specific portions of the compiled software that may introduce risks during execution. For each time period, it determines intermediate relationships between these mappings and various attributes of the software program, such as performance, security vulnerabilities, or stability issues. The system then evaluates the likelihood that different subsets of factors—such as code changes, environmental conditions, or external dependencies—will interfere with the software's execution based on these relationships. By continuously analyzing these interactions, the system provides insights into potential risks and their probable impact, enabling proactive mitigation strategies. The approach leverages historical and real-time data to enhance software reliability and security.
9. The system of claim 8 , wherein the one or more processors are configured to: correlate the one or more intermediate relationships that correspond to a first time period of the plurality of time periods to the one or more intermediate relationships that correspond to a second time period of the plurality of time periods to provide one or more temporal relationships; and determine the one or more likelihoods that the one or more respective subsets of the plurality of factors are to interfere with the execution of the software program further based at least in part on the one or more temporal relationships.
This invention relates to a system for analyzing software execution interference by evaluating temporal relationships between factors affecting performance. The system identifies intermediate relationships between multiple factors during different time periods and correlates these relationships across time to determine temporal patterns. By analyzing these temporal relationships, the system assesses the likelihood that specific subsets of factors will interfere with software program execution. The system processes data from multiple time periods to establish how factor interactions evolve over time, improving the accuracy of interference predictions. This approach helps in identifying persistent or recurring issues that may degrade software performance, allowing for proactive mitigation. The system dynamically adjusts its interference likelihood assessments based on temporal correlations, enhancing reliability in dynamic environments. The invention addresses the challenge of predicting software performance issues by leveraging time-based factor interactions, providing a more robust analysis compared to static evaluations.
10. The system of claim 8 , wherein the one or more processors are configured to: correlate a specified change that occurs with respect to at least one specified source code file of the plurality of source code files during a designated time period of the plurality of time periods to at least one new functionality that is added to the software program and that is addressed by the specified change to provide a specified correlation; and determine the one or more likelihoods that the one or more respective subsets of the plurality of factors are to interfere with the execution of the software program further based at least in part on the specified correlation.
This invention relates to software development and testing, specifically to systems that analyze source code changes to assess potential execution risks. The system monitors a plurality of source code files over multiple time periods, tracking changes made to these files. When a change is detected in a specified source code file during a designated time period, the system correlates that change to a new functionality added to the software program. This correlation helps identify how the change contributes to the software's functionality. The system then evaluates the likelihood that various subsets of factors—such as code complexity, dependencies, or historical error rates—will interfere with the software's execution, using the correlation as part of its analysis. By linking code changes to specific functionalities, the system improves risk assessment, allowing developers to prioritize testing and debugging efforts more effectively. The approach enhances software reliability by ensuring that changes are systematically analyzed for potential execution issues before deployment.
11. The system of claim 8 , wherein the one or more processors are configured to: correlate a specified change that occurs with respect to at least one specified source code file of the plurality of source code files during a designated time period of the plurality of time periods to at least one enhancement to an existing functionality of the software program that is addressed by the specified change to provide a specified correlation; and determine the one or more likelihoods that the one or more respective subsets of the plurality of factors are to interfere with the execution of the software program further based at least in part on the specified correlation.
The system analyzes software development processes to identify potential execution issues by correlating code changes with software functionality enhancements. It tracks changes made to source code files during specific time periods and links those changes to improvements in existing software features. By establishing this correlation, the system assesses the likelihood that various factors—such as code complexity, dependencies, or environmental variables—will interfere with software execution. The system processes multiple source code files and evaluates how modifications impact functionality, using this data to predict risks. It also considers historical patterns and contextual factors to refine its interference likelihood assessments. The goal is to proactively identify and mitigate risks before they affect software performance, ensuring smoother execution and reducing downtime. The system integrates these analyses into a broader framework that monitors software development activities, providing developers with actionable insights to maintain stability and reliability.
12. The system of claim 8 , wherein the one or more processors are configured to: for a designated time period of the plurality of time periods, determine a specified intermediate relationship between a designated mapping, which maps one or more designated changes that occur with respect to at least one source code file of the plurality of source code files during the designated time period to at least one portion of the compiled representation of the software program that includes a defect, and a developer who makes at least one of the one or more designated changes; and determine the one or more likelihoods based at least in part on the specified intermediate relationship indicating that the defect is attributable to the developer who makes the at least one of the one or more designated changes.
The system analyzes software development processes to identify developers responsible for defects in compiled code. It tracks changes made to source code files over multiple time periods and maps these changes to specific portions of the compiled software representation where defects are detected. For a selected time period, the system establishes a relationship between a specific mapping (which links code changes to defective code portions) and the developer who made those changes. The system then calculates the likelihood that the defect is attributable to that developer based on this relationship. This helps in pinpointing responsibility for defects by correlating developer activity with code issues, improving accountability and debugging efficiency. The system processes multiple source code files and their compiled outputs, analyzing temporal patterns of changes to determine defect attribution probabilities. The approach enhances defect tracking by leveraging intermediate relationships between code modifications and their impact on software quality.
13. The system of claim 8 , wherein at least one mapping for each time period is associated with an extensible markup language (XML) schema.
The system relates to data processing and management, specifically for organizing and retrieving information across different time periods. The core problem addressed is the need for a structured and flexible way to handle data mappings over time, ensuring consistency and interoperability. The system includes a data storage component that stores data records, each associated with a time period. A mapping module generates mappings between data records from different time periods, allowing for the transformation or translation of data between these periods. These mappings are stored in a mapping database, enabling the system to retrieve and apply the appropriate mappings when processing data. The system also includes a user interface for managing and querying the data, providing users with tools to interact with the stored records and mappings. A key feature is that at least one mapping for each time period is associated with an extensible markup language (XML) schema, ensuring that the data and its transformations adhere to a standardized format. This schema-based approach enhances data integrity and facilitates integration with other systems that use XML for data exchange. The system is designed to support dynamic updates to mappings and schemas, allowing it to adapt to evolving data requirements.
14. The system of claim 8 , wherein the one or more processors are configured to: correlate the one or more source code files for each time period to one or more functions of the software program to provide one or more second correlations, each function corresponding to a respective sub-routine of the software program; and wherein the one or more mappings for each time period is based at least in part on the one or more second correlations.
This invention relates to software analysis systems that track changes in source code over time. The problem addressed is the difficulty in understanding how software evolves, particularly in linking code modifications to specific functions or sub-routines within a program. Existing systems may track changes at a file level but lack granularity in associating modifications with individual functions, making it hard to analyze functional evolution or identify regressions. The system includes processors that analyze source code files across different time periods. For each time period, the processors correlate the source code files with specific functions of the software program, where each function corresponds to a sub-routine. These correlations are used to generate mappings that show how functions change over time. The mappings are based on these function-level correlations, providing a detailed view of how individual sub-routines evolve. This allows developers to trace changes at a finer granularity than file-level tracking, improving debugging, maintenance, and version control. The system enhances software analysis by linking modifications to specific functions, enabling more precise tracking of functional behavior and dependencies over time.
15. A computer program product comprising a computer-readable storage device having computer program logic recorded thereon for enabling a processor-based system to perform automatic risk analysis of a software program, the computer program product comprising: means for determining, for each time period of a plurality of time periods, one or more intermediate relationships between one or more mappings for that time period and one or more attributes of a software program, the one or more mappings for each time period mapping one or more changes that occur with respect to one or more source code files of a plurality of source code files during the respective time period to one or more portions of a compiled representation of the software program that represent at least one risk for the software program during execution; and means for determining one or more likelihoods that one or more respective subsets of a plurality of factors are to interfere with execution of the software program based at least in part on the one or more intermediate relationships.
This invention relates to automated risk analysis of software programs, specifically identifying potential risks during execution by analyzing changes in source code and their impact on compiled representations. The system tracks modifications to source code files over multiple time periods and maps these changes to portions of the compiled program that may introduce risks. For each time period, it determines intermediate relationships between these mappings and software attributes, such as performance, security, or stability. The system then evaluates the likelihood that subsets of factors—such as code dependencies, execution conditions, or environmental variables—will interfere with program execution based on these relationships. The goal is to proactively identify and assess risks before they manifest during runtime, improving software reliability and security. The approach involves dynamic analysis of code changes and their compiled outputs, enabling early detection of vulnerabilities or performance issues. This method supports continuous monitoring and risk assessment throughout the software development lifecycle.
16. The computer program product of claim 15 , further comprising: means for correlating the one or more intermediate relationships that correspond to a first time period of the plurality of time periods to the one or more intermediate relationships that correspond to a second time period of the plurality of time periods to provide one or more temporal relationships; wherein the means for determining the one or more likelihoods comprises: means for determining the one or more likelihoods that the one or more respective subsets of the plurality of factors are to interfere with the execution of the software program further based at least in part on the one or more temporal relationships.
This invention relates to software execution analysis, specifically identifying factors that may interfere with software program execution over time. The system analyzes a plurality of factors that could impact software performance, such as system resources, dependencies, or environmental conditions. These factors are grouped into subsets, and intermediate relationships between them are established for different time periods. The system then correlates these intermediate relationships across time periods to derive temporal relationships, which reveal how factor interactions evolve. Using these temporal relationships, the system determines the likelihood that specific subsets of factors will interfere with software execution. The analysis accounts for both static and dynamic influences, improving accuracy in predicting performance disruptions. The method enhances software reliability by proactively identifying potential issues based on historical and real-time data patterns.
17. The computer program product of claim 15 , further comprising: means for correlating a specified change that occurs with respect to at least one specified source code file of the plurality of source code files during a designated time period of the plurality of time periods to at least one new functionality that is being added to the software program and that is addressed by the specified change to provide a specified correlation; wherein the means for determining the one or more likelihoods comprises: means for determining the one or more likelihoods that the one or more respective subsets of the plurality of factors are to interfere with the execution of the software program further based at least in part on the specified correlation.
This invention relates to software development and quality assurance, specifically to a system for analyzing source code changes and their impact on software functionality. The problem addressed is the difficulty in predicting how changes to source code files may affect software execution, particularly when multiple factors (such as code modifications, dependencies, or environmental conditions) interact in complex ways. The solution involves a computer program product that correlates specific changes in source code files during a designated time period with new functionalities being added to the software. By analyzing these correlations, the system determines the likelihood that subsets of factors (e.g., code changes, dependencies, or other variables) will interfere with software execution. The correlation process helps identify which changes are most likely to introduce issues, allowing developers to prioritize testing or mitigation efforts. The system dynamically adjusts its predictions based on historical data and the relationships between code changes and new features, improving accuracy over time. This approach enhances software reliability by proactively identifying potential risks before they manifest in production environments.
18. The computer program product of claim 15 , further comprising: means for correlating a specified change that occurs with respect to at least one specified source code file of the plurality of source code files during a designated time period of the plurality of time periods to at least one enhancement to an existing functionality of the software program that is addressed by the specified change to provide a specified correlation; wherein the means for determining the one or more likelihoods comprises: means for determining the one or more likelihoods that the one or more respective subsets of the plurality of factors are to interfere with the execution of the software program further based at least in part on the specified correlation.
19. The computer program product of claim 15 , wherein the means for determining, for each time period of the plurality of time periods, the one or more intermediate relationships comprises: means for determining, for a designated time period of the plurality of time periods, a specified intermediate relationship between a designated mapping, which maps one or more designated changes that occur with respect to at least one source code file of the plurality of source code files during the designated time period to at least one portion of the compiled representation of the software program that includes a defect, and a developer who makes at least one of the one or more designated changes; and wherein the means for determining the one or more likelihoods comprises: means for determining the one or more likelihoods based at least in part on the specified intermediate relationship indicating that the defect is attributable to the developer who makes the at least one of the one or more designated changes.
This invention relates to software defect attribution in compiled programs. The problem addressed is identifying which developers are responsible for defects in compiled software by analyzing changes made to source code over time. The system tracks changes to source code files and correlates them with defects in the compiled output. For each time period, it determines intermediate relationships between specific code changes and defects, linking them to the developers who made those changes. The system then calculates likelihoods that a developer is responsible for a defect based on these relationships. The analysis involves mapping changes in source code to portions of the compiled program where defects are found, then associating those changes with the developers who implemented them. This helps pinpoint accountability for defects in large software projects where multiple developers contribute over time. The approach improves debugging efficiency by providing data-driven insights into defect origins.
20. The computer program product of claim 15 , further comprising: means for correlating the one or more source code files for each time period to one or more functions of the software program to provide one or more second correlations, each function corresponding to a respective sub-routine of the software program; wherein the one or more mappings for each time period is based at least in part on the one or more second correlations.
This invention relates to software analysis, specifically tracking changes in source code files over time and correlating them with software program functions. The problem addressed is the difficulty in understanding how modifications to source code files impact specific functions or sub-routines within a software program, particularly in large or complex systems where changes may span multiple files and time periods. The invention provides a method for analyzing source code changes by correlating source code files with software functions. It involves tracking modifications to one or more source code files over multiple time periods, where each time period represents a distinct version or snapshot of the software. The system then correlates these source code files with specific functions of the software program, where each function corresponds to a sub-routine. These correlations are used to generate mappings that show how changes in source code files relate to changes in software functions over time. The mappings help developers and analysts understand the impact of code modifications on specific program behaviors, improving debugging, maintenance, and version control processes. The invention enhances software development workflows by providing clearer insights into the relationship between code changes and functional outcomes.
Unknown
August 18, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.