• Xie D, Chen B, Huang K, Wang Y, Pan L, Chen Z and Peng X. (2024). Enhancing Field Tracking and Interprocedural Analysis to Find More Null Pointer Exceptions 2024 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). 10.1109/SANER60148.2024.00093. 979-8-3503-3066-3. (849-859).

    https://ieeexplore.ieee.org/document/10589821/

  • Guo Z, Tan T, Liu S, Liu X, Lai W, Yang Y, Li Y, Chen L, Dong W and Zhou Y. Mitigating False Positive Static Analysis Warnings: Progress, Challenges, and Opportunities. IEEE Transactions on Software Engineering. 10.1109/TSE.2023.3329667. 49:12. (5154-5188).

    https://ieeexplore.ieee.org/document/10305541/

  • Karimipour N, Pham J, Clapp L and Sridharan M. Practical Inference of Nullability Types. Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. (1395-1406).

    https://doi.org/10.1145/3611643.3616326

  • Kellogg M, Daskiewicz D, Duc Nguyen L, Ahmed M and Ernst M. (2023). Pluggable Type Inference for Free 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). 10.1109/ASE56229.2023.00186. 979-8-3503-2996-4. (1542-1554).

    https://ieeexplore.ieee.org/document/10298459/

  • Moradi Dakhel A, Majdinasab V, Nikanjam A, Khomh F, Desmarais M and Jiang Z. (2023). GitHub Copilot AI pair programmer: Asset or Liability?. Journal of Systems and Software. 10.1016/j.jss.2023.111734. 203. (111734). Online publication date: 1-Sep-2023.

    https://linkinghub.elsevier.com/retrieve/pii/S0164121223001292

  • Riouak I, Reichenbach C, Hedin G and Fors N. (2021). A Precise Framework for Source-Level Control-Flow Analysis 2021 IEEE 21st International Working Conference on Source Code Analysis and Manipulation (SCAM). 10.1109/SCAM52516.2021.00009. 978-1-6654-4897-0. (1-11).

    https://ieeexplore.ieee.org/document/9610697/

  • Yasuda K, Itoh S, Mibe R, Jodai Y and Nakaya F. (2019). Inferring Faults in Business Specifications Extracted from Source Code 2019 26th Asia-Pacific Software Engineering Conference (APSEC). 10.1109/APSEC48747.2019.00040. 978-1-7281-4648-5. (236-243).

    https://ieeexplore.ieee.org/document/8945593/

  • Kim J, Batory D and Gligoric M. Code transformation issues in move-instance-method refactorings. Proceedings of the 3rd International Workshop on Refactoring. (17-22).

    https://doi.org/10.1109/IWoR.2019.00011

  • Shi Q, Xiao X, Wu R, Zhou J, Fan G and Zhang C. (2018). Pinpoint: fast and precise sparse value flow analysis for million lines of code. ACM SIGPLAN Notices. 53:4. (693-706). Online publication date: 2-Dec-2018.

    https://doi.org/10.1145/3296979.3192418

  • Shi Q, Xiao X, Wu R, Zhou J, Fan G and Zhang C. Pinpoint: fast and precise sparse value flow analysis for million lines of code. Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation. (693-706).

    https://doi.org/10.1145/3192366.3192418

  • Leuenberger M, Osman H, Ghafari M and Nierstrasz O. (2017). Harvesting the Wisdom of the Crowd to Infer Method Nullness in Java 2017 IEEE 17th International Working Conference on Source Code Analysis and Manipulation (SCAM). 10.1109/SCAM.2017.22. 978-1-5386-3238-3. (71-80).

    http://ieeexplore.ieee.org/document/8090140/

  • Ore J, Detweiler C and Elbaum S. Lightweight detection of physical unit inconsistencies without program annotations. Proceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis. (341-351).

    https://doi.org/10.1145/3092703.3092722

  • Kanvar V and Khedker U. (2016). Heap Abstractions for Static Analysis. ACM Computing Surveys. 49:2. (1-47). Online publication date: 11-Nov-2016.

    https://doi.org/10.1145/2931098

  • Osman H, Leuenberger M, Lungu M and Nierstrasz O. (2016). Tracking Null Checks in Open-Source Java Systems 2016 IEEE 23rd International Conference on Software Analysis, Evolution and Reengineering (SANER). 10.1109/SANER.2016.57. 978-1-5090-1855-0. (304-313).

    http://ieeexplore.ieee.org/document/7476652/

  • Ma S, Jiao M, Zhang S, Zhao W and Wang D. Practical null pointer dereference detection via value-dependence analysis. Proceedings of the 2015 IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW). (70-77).

    https://doi.org/10.1109/ISSREW.2015.7392049

  • Brutschy L, Ferrara P and Müller P. (2014). Static analysis for independent app developers. ACM SIGPLAN Notices. 49:10. (847-860). Online publication date: 31-Dec-2015.

    https://doi.org/10.1145/2714064.2660219

  • Brutschy L, Ferrara P and Müller P. Static analysis for independent app developers. Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications. (847-860).

    https://doi.org/10.1145/2660193.2660219

  • Kimura S, Hotta K, Higo Y, Igaki H and Kusumoto S. (2014). Does return null matter? 2014 Software Evolution Week - IEEE Conference on Software Maintenance, Reengineering and Reverse Engineering (CSMR-WCRE). 10.1109/CSMR-WCRE.2014.6747176. 978-1-4799-3752-3. (244-253).

    http://ieeexplore.ieee.org/document/6747176/

  • Liang G, Wang Q, Xie T and Mei H. Inferring project-specific bug patterns for detecting sibling bugs. Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering. (565-575).

    https://doi.org/10.1145/2491411.2491422

  • Díaz G and Bermejo J. (2013). Static analysis of source code security. Information and Software Technology. 55:8. (1462-1476). Online publication date: 1-Aug-2013.

    https://doi.org/10.1016/j.infsof.2013.02.005

  • Chan W and Cai Y. (2011). In quest of the science in statistical fault localization. Software: Practice and Experience. 10.1002/spe.1147. 43:8. (971-987). Online publication date: 1-Aug-2013.

    https://onlinelibrary.wiley.com/doi/10.1002/spe.1147

  • Fehnker A and Huuck R. (2013). Model checking driven static analysis for the real world. Innovations in Systems and Software Engineering. 9:1. (45-56). Online publication date: 1-Mar-2013.

    https://doi.org/10.1007/s11334-012-0192-5

  • Chen J. (2013). Detecting Null Dereference with a Game. Proceedings of the 2012 International Conference on Information Technology and Software Engineering. 10.1007/978-3-642-34531-9_1. (3-10).

    https://link.springer.com/10.1007/978-3-642-34531-9_1

  • Monperrus M, Eichberg M, Tekes E and Mezini M. (2012). What should developers be aware of? An empirical study on the directives of API documentation. Empirical Software Engineering. 17:6. (703-737). Online publication date: 1-Dec-2012.

    https://doi.org/10.1007/s10664-011-9186-4

  • Coughlin D, Chang B, Diwan A and Siek J. Measuring enforcement windows with symbolic trace interpretation: what well-behaved programs say. Proceedings of the 2012 International Symposium on Software Testing and Analysis. (276-286).

    https://doi.org/10.1145/2338965.2336786

  • Madhavan R and Komondoor R. Null dereference verification via over-approximated weakest pre-conditions analysis. Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications. (1033-1052).

    https://doi.org/10.1145/2048066.2048144

  • Madhavan R and Komondoor R. (2011). Null dereference verification via over-approximated weakest pre-conditions analysis. ACM SIGPLAN Notices. 46:10. (1033-1052). Online publication date: 18-Oct-2011.

    https://doi.org/10.1145/2076021.2048144

  • Wu X, Xu Z and Wei J. Static Detection of Bugs Caused by Incorrect Exception Handling in Java Programs. Proceedings of the 2011 11th International Conference on Quality Software. (61-66).

    https://doi.org/10.1109/QSIC.2011.25

  • Dietl W, Dietzel S, Ernst M, Muşlu K and Schiller T. Building and using pluggable type-checkers. Proceedings of the 33rd International Conference on Software Engineering. (681-690).

    https://doi.org/10.1145/1985793.1985889

  • Spoto F and Ernst M. Inference of field initialization. Proceedings of the 33rd International Conference on Software Engineering. (231-240).

    https://doi.org/10.1145/1985793.1985826

  • Spoto F. (2011). Precise null-pointer analysis. Software and Systems Modeling (SoSyM). 10:2. (219-252). Online publication date: 1-May-2011.

    https://doi.org/10.1007/s10270-009-0132-5

  • Ernst M and Ali M. Building and using pluggable type systems. Proceedings of the eighteenth ACM SIGSOFT international symposium on Foundations of software engineering. (375-376).

    https://doi.org/10.1145/1882291.1882356

  • Schmeelk S. (2010). Static checking java with the Java Static Checker 2010 2nd International Conference on Software Technology and Engineering (ICSTE 2010). 10.1109/ICSTE.2010.5608841. 978-1-4244-8667-0.

    http://ieeexplore.ieee.org/document/5608841/

  • Jiang S, Zhang H, Wang Q and Zhang Y. A Debugging Approach for Java Runtime Exceptions Based on Program Slicing and Stack Traces. Proceedings of the 2010 10th International Conference on Quality Software. (393-398).

    https://doi.org/10.1109/QSIC.2010.23

  • Feiner J. The fluid software metadata framework (FSM). Proceedings of the 2nd ACM SIGCHI symposium on Engineering interactive computing systems. (333-336).

    https://doi.org/10.1145/1822018.1822074

  • Kim M, Sinha S, Görg C, Shah H, Harrold M and Nanda M. Automated Bug Neighborhood Analysis for Identifying Incomplete Bug Fixes. Proceedings of the 2010 Third International Conference on Software Testing, Verification and Validation. (383-392).

    https://doi.org/10.1109/ICST.2010.63

  • Sinha S, Shah H, Görg C, Jiang S, Kim M and Harrold M. Fault localization and repair for Java runtime exceptions. Proceedings of the eighteenth international symposium on Software testing and analysis. (153-164).

    https://doi.org/10.1145/1572272.1572291

  • Nanda M and Sinha S. Accurate Interprocedural Null-Dereference Analysis for Java. Proceedings of the 31st International Conference on Software Engineering. (133-143).

    https://doi.org/10.1109/ICSE.2009.5070515

  • Qi X and Myers A. (2009). Masked types for sound object initialization. ACM SIGPLAN Notices. 44:1. (53-65). Online publication date: 21-Jan-2009.

    https://doi.org/10.1145/1594834.1480890

  • Qi X and Myers A. Masked types for sound object initialization. Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (53-65).

    https://doi.org/10.1145/1480881.1480890

  • Ayewah N, Hovemeyer D, Morgenthaler J, Penix J and Pugh W. (2008). Using Static Analysis to Find Bugs. IEEE Software. 25:5. (22-29). Online publication date: 1-Sep-2008.

    https://doi.org/10.1109/MS.2008.130

  • Ayewah N and Pugh W. A report on a survey and study of static analysis users. Proceedings of the 2008 workshop on Defects in large software systems. (1-5).

    https://doi.org/10.1145/1390817.1390819

  • Papi M, Ali M, Correa T, Perkins J and Ernst M. Practical pluggable types for java. Proceedings of the 2008 international symposium on Software testing and analysis. (201-212).

    https://doi.org/10.1145/1390630.1390656

  • Male C, Pearce D, Potanin A and Dymnikov C. Java bytecode verification for @NonNull types. Proceedings of the Joint European Conferences on Theory and Practice of Software 17th international conference on Compiler construction. (229-244).

    /doi/10.5555/1788374.1788395

  • Male C, Pearce D, Potanin A and Dymnikov C. Java Bytecode Verification for @NonNull Types. Compiler Construction. 10.1007/978-3-540-78791-4_16. (229-244).

    http://link.springer.com/10.1007/978-3-540-78791-4_16

  • Bond M, Nethercote N, Kent S, Guyer S and McKinley K. (2007). Tracking bad apples. ACM SIGPLAN Notices. 42:10. (405-422). Online publication date: 21-Oct-2007.

    https://doi.org/10.1145/1297105.1297057

  • Bond M, Nethercote N, Kent S, Guyer S and McKinley K. Tracking bad apples. Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems, languages and applications. (405-422).

    https://doi.org/10.1145/1297027.1297057

  • Quinlan D, Vuduc R and Misherghi G. Techniques for specifying bug patterns. Proceedings of the 2007 ACM workshop on Parallel and distributed systems: testing and debugging. (27-35).

    https://doi.org/10.1145/1273647.1273654

  • Dillig I, Dillig T and Aiken A. Static error detection using semantic inconsistency inference. Proceedings of the 28th ACM SIGPLAN Conference on Programming Language Design and Implementation. (435-445).

    https://doi.org/10.1145/1250734.1250784

  • Foster J, Hicks M and Pugh W. Improving software quality with static analysis. Proceedings of the 7th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering. (83-84).

    https://doi.org/10.1145/1251535.1251549

  • Hovemeyer D and Pugh W. Finding more null pointer bugs, but not too many. Proceedings of the 7th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering. (9-14).

    https://doi.org/10.1145/1251535.1251537

  • Dillig I, Dillig T and Aiken A. (2007). Static error detection using semantic inconsistency inference. ACM SIGPLAN Notices. 42:6. (435-445). Online publication date: 10-Jun-2007.

    https://doi.org/10.1145/1273442.1250784

  • COUSOT P, COUSOT R, FERET J, MINE A, MAUBORGNE L, MONNIAUX D and RIVAL X. Varieties of Static Analyzers. Proceedings of the First Joint IEEE/IFIP Symposium on Theoretical Aspects of Software Engineering. (3-20).

    https://doi.org/10.1109/TASE.2007.55

    • Mayo Q and Bryce R. (2018). Detection of Generalizable Clone Security Coding Bugs Using Graphs and Learning Algorithms . 10.12794/metadc1404548
  • Amankwah R, Chen J, Song H and Kudjo P. (2022). Bug detection in Java code: An extensive evaluation of static analysis tools using Juliet Test Suites. Software: Practice and Experience. 10.1002/spe.3181. 53:5. (1125-1143). Online publication date: 1-May-2023.

    https://onlinelibrary.wiley.com/doi/10.1002/spe.3181

  • Costa D, Mujahid S, Abdalkareem R and Shihab E. Breaking Type Safety in Go: An Empirical Study on the Usage of the unsafe Package. IEEE Transactions on Software Engineering. 10.1109/TSE.2021.3057720. 48:7. (2277-2294).

    https://ieeexplore.ieee.org/document/9350178/

  • Ma S, Li J, Nepal S, Ostry D, Lo D, Jha S, Deng R and Bertino E. Orchestration or Automation: Authentication Flaw Detection in Android Apps. IEEE Transactions on Dependable and Secure Computing. 10.1109/TDSC.2021.3050188. 19:4. (2165-2178).

    https://ieeexplore.ieee.org/document/9317767/

  • Zhai Y, Hao Y, Zhang H, Wang D, Song C, Qian Z, Lesani M, Krishnamurthy S and Yu P. UBITect: a precise and scalable method to detect use-before-initialization bugs in Linux kernel. Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. (221-232).

    https://doi.org/10.1145/3368089.3409686

  • Diamantopoulos T and Symeonidis A. (2020). Theoretical Background and State-of-the-Art. Mining Software Engineering Data for Software Reuse. 10.1007/978-3-030-30106-4_2. (13-43).

    http://link.springer.com/10.1007/978-3-030-30106-4_2

  • Duan J, Jiang S, Yu Q, Lu K, Zhang X and Yao Y. An Automatic Localization Tool for Null Pointer Exceptions. IEEE Access. 10.1109/ACCESS.2019.2948366. (1-1).

    https://ieeexplore.ieee.org/document/8876852/

  • Shi Q, Xiao X, Wu R, Zhou J, Fan G and Zhang C. (2018). Pinpoint: fast and precise sparse value flow analysis for million lines of code. ACM SIGPLAN Notices. 53:4. (693-706). Online publication date: 2-Dec-2018.

    https://doi.org/10.1145/3296979.3192418

  • Shi Q, Xiao X, Wu R, Zhou J, Fan G and Zhang C. Pinpoint: fast and precise sparse value flow analysis for million lines of code. Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation. (693-706).

    https://doi.org/10.1145/3192366.3192418

  • Ore J, Detweiler C and Elbaum S. Lightweight detection of physical unit inconsistencies without program annotations. Proceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis. (341-351).

    https://doi.org/10.1145/3092703.3092722

  • Barabanov A, Markov A, Fadin A and Tsirlov V. A Production Model System for Detecting Vulnerabilities in the Software Source Code. Proceedings of the 8th International Conference on Security of Information and Networks. (98-99).

    https://doi.org/10.1145/2799979.2800019

  • Dubey A and Murthy P. Computation and visualization of cause-effect paths. Proceedings of the 8th International Workshop on Automation of Software Test. (139-145).

    /doi/10.5555/2662413.2662444

  • Dubey A and Murthy P. (2013). Computation and visualization of cause-effect paths 2013 8th International Workshop on Automation of Software Test (AST). 10.1109/IWAST.2013.6595805. 978-1-4673-6161-3. (139-145).

    http://ieeexplore.ieee.org/document/6595805/

  • Wu L, Liang G, Kui S and Wang Q. CEclipse. Proceedings of the 2011 IEEE World Congress on Services. (45-52).

    https://doi.org/10.1109/SERVICES.2011.74

  • Hoenicke J, Leino K, Podelski A, Schäf M and Wies T. (2010). Doomed program points. Formal Methods in System Design. 37:2-3. (171-199). Online publication date: 1-Dec-2010.

    https://doi.org/10.1007/s10703-010-0102-0

  • Le Goues C, Forrest S and Weimer W. The case for software evolution. Proceedings of the FSE/SDP workshop on Future of software engineering research. (205-210).

    https://doi.org/10.1145/1882362.1882406

  • Hoenicke J, Leino K, Podelski A, Schäf M and Wies T. It's Doomed; We Can Prove It. Proceedings of the 2nd World Congress on Formal Methods. (338-353).

    https://doi.org/10.1007/978-3-642-05089-3_22

  • Dobolyi K and Weimer W. Changing Java's Semantics for Handling Null Pointer Exceptions. Proceedings of the 2008 19th International Symposium on Software Reliability Engineering. (47-56).

    https://doi.org/10.1109/ISSRE.2008.59

  • Hubert L. A non-null annotation inferencer for Java bytecode. Proceedings of the 8th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering. (36-42).

    https://doi.org/10.1145/1512475.1512484

  • Hubert L, Jensen T and Pichardie D. Semantic Foundations and Inference of Non-null Annotations. Proceedings of the 10th IFIP WG 6.1 international conference on Formal Methods for Open Object-Based Distributed Systems. (132-149).

    https://doi.org/10.1007/978-3-540-68863-1_9

  • Chalin P, James P and Rioux F. (2008). Reducing the use of nullable types through non-null by default and monotonic non-null. IET Software. 10.1049/iet-sen:20080010. 2:6. (515).

    https://digital-library.theiet.org/content/journals/10.1049/iet-sen_20080010

  • Chalin P and James P. Non-null references by default in java. Proceedings of the 21st European conference on Object-Oriented Programming. (227-247).

    /doi/10.5555/2394758.2394776

  • Chalin P and James P. (2007). Non-null References by Default in Java: Alleviating the Nullity Annotation Burden. ECOOP 2007 – Object-Oriented Programming. 10.1007/978-3-540-73589-2_12. (227-247).

    http://link.springer.com/10.1007/978-3-540-73589-2_12