The APOBEC3 family of cytosine deaminases has been implicated in some of the most prevalent mutational signatures in cancer1–3. However, a causal link between endogenous APOBEC3 enzymes and mutational signatures in human cancer genomes has not been established, leaving the mechanisms of APOBEC3 mutagenesis poorly understood. Here, to investigate the mechanisms of APOBEC3 mutagenesis, we deleted implicated genes from human cancer cell lines that naturally generate APOBEC3-associated mutational signatures over time4. Analysis of non-clustered and clustered signatures across whole-genome sequences from 251 breast, bladder and lymphoma cancer cell line clones revealed that APOBEC3A deletion diminished APOBEC3-associated mutational signatures. Deletion of both APOBEC3A and APOBEC3B further decreased APOBEC3 mutation burdens, without eliminating them. Deletion of APOBEC3B increased APOBEC3A protein levels, activity and APOBEC3A-mediated mutagenesis in some cell lines. The uracil glycosylase UNG was required for APOBEC3-mediated transversions, whereas the loss of the translesion polymerase REV1 decreased overall mutation burdens. Together, these data represent direct evidence that endogenous APOBEC3 deaminases generate prevalent mutational signatures in human cancer cells. Our results identify APOBEC3A as the main driver of these mutations, indicate that APOBEC3B can restrain APOBEC3A-dependent mutagenesis while contributing its own smaller mutation burdens and dissect mechanisms that translate APOBEC3 activities into distinct mutational signatures.

Abstract-Several recent studies indicate that many industrial applications exhibit poor quality in the design of exception-handling. To improve the quality of error-handling, we need to understand the problems and obstacles that developers face when designing and implementing exception-handling. In this paper, we present our research on understanding the viewpoint of developers-novices and experts-toward exception-handling. First, we conducted a study with novice developers in industry. The study results reveal that novices tend to ignore exceptions because of the complex nature of exception-handling. Then, we conducted a second study with experts in industry to understand their perspective on exception-handling. The study results show that, for experts, exception-handling is a crucial part in the development process. Experts also confirm the novices' approach of ignoring exception-handling and provide insights as to why novices do so. After analyzing the study data, we identified factors that influence experts' strategy selection process for handling exceptions and then built a model that represents a strategy selection process experts use to handle exceptions. Our model is based on interacting modules and fault scope. We conclude with some recommendations to help novices improve their understanding of exception-handling.

No abstract

This paper presents a new approach for locating and repairing faults that cause runtime exceptions in Java programs. The approach handles runtime exceptions that involve a flow of an incorrect value that finally leads to the exception. This important class of exceptions includes exceptions related to dereferences of null pointers, arithmetic faults (e.g., ArithmeticException), and type faults (e.g., ArrayStoreException). Given a statement at which such an exception occurred, the technique combines dynamic analysis (using stack-trace information) with static backward data-flow analysis (beginning at the point where the runtime exception occurred) to identify the source statement at which an incorrect assignment was made; this information is required to locate the fault. The approach also identifies the source statements that may cause this same exception on other executions, along with the reference statements that may raise an exception in other executions because of this incorrect assignment; this information is required to repair the fault. The paper also presents an application of our technique to null pointer exceptions. Finally, the paper describes an implementation of the null-pointer-exception analysis and a set of studies that demonstrate the advantages of our approach for locating and repairing faults in the program.

This paper presents a new visualization technique for supporting the understanding of exception-handling constructs in Java programs. To understand the requirements for such a visualization, we surveyed a group of software developers, and used the results of that survey to guide the creation of the visualizations. The technique presents the exception-handling information using three views: the quantitative view, the flow view, and the contextual view. The quantitative view provides a high-level view that shows the throw-catch interactions in the program, along with relative numbers of these interactions, at the package level, the class level, and the method level. The flow view shows the type-throw-catch interactions, illustrating information such as which exception types reach particular throw statements, which catch statements handle particular throw statements, and which throw statements are not caught in the program. The contextual view shows, for particular type-throw-catch interactions, the packages, classes, and methods that contribute to that exception-handling construct. The paper also presents a case study in which we evaluated a prototype of the visualization system on a small set of developers.