• Yan A, Zhong H, Song D and Jia L. (2023). How do programmers fix bugs as workarounds? An empirical study on Apache projects. Empirical Software Engineering. 28:4. Online publication date: 1-Jul-2023.

    https://doi.org/10.1007/s10664-023-10318-7

  • He X, Liu X, Xu L and Xu B. (2023). How Dynamic Features Affect API Usages? An Empirical Study of API Misuses in Python Programs 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). 10.1109/SANER56733.2023.00055. 978-1-6654-5278-6. (522-533).

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

  • Dilhara M, Ketkar A and Dig D. (2021). Understanding Software-2.0. ACM Transactions on Software Engineering and Methodology. 30:4. (1-42). Online publication date: 31-Oct-2021.

    https://doi.org/10.1145/3453478

  • Andrade G, Griebler D, Santos R, Danelutto M and Fernandes L. (2021). Assessing Coding Metrics for Parallel Programming of Stream Processing Programs on Multi-cores 2021 47th Euromicro Conference on Software Engineering and Advanced Applications (SEAA). 10.1109/SEAA53835.2021.00044. 978-1-6654-2705-0. (291-295).

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

  • Terragni V and Pezzè M. (2021). Statically driven generation of concurrent tests for thread‐safe classes. Software Testing, Verification and Reliability. 10.1002/stvr.1774. 31:4. Online publication date: 1-Jun-2021.

    https://onlinelibrary.wiley.com/doi/10.1002/stvr.1774

  • Khanna D, Purandare R and Sharma S. (2021). Synthesizing Multi-threaded Tests from Sequential Traces to Detect Communication Deadlocks 2021 14th IEEE Conference on Software Testing, Verification and Validation (ICST). 10.1109/ICST49551.2021.00013. 978-1-7281-6836-4. (1-12).

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

  • Zhong H, Meng N, Li Z and Jia L. An empirical study on API parameter rules. Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering. (899-911).

    https://doi.org/10.1145/3377811.3380922

  • Saissi H, Winter S, Schwahn O, Pattabiraman K and Suri N. (2020). TraceSanitizer - Eliminating the Effects of Non-Determinism on Error Propagation Analysis 2020 50th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN). 10.1109/DSN48063.2020.00025. 978-1-7281-5809-9. (52-63).

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

  • Chen L, Wu D, Ma W, Zhou Y, Xu B and Leung H. (2020). How C++ Templates Are Used for Generic Programming. ACM Transactions on Software Engineering and Methodology. 29:1. (1-49). Online publication date: 31-Jan-2020.

    https://doi.org/10.1145/3356579

  • Gu Z, Wu J, Liu J, Zhou M and Gu M. (2019). An Empirical Study on API-Misuse Bugs in Open-Source C Programs 2019 IEEE 43rd Annual Computer Software and Applications Conference (COMPSAC). 10.1109/COMPSAC.2019.00012. 978-1-7281-2607-4. (11-20).

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

  • Eyolfson J and Lam P. How C++ developers use immutability declarations. Proceedings of the 41st International Conference on Software Engineering. (362-372).

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

  • Zhong H and Mei H. An Empirical Study on API Usages. IEEE Transactions on Software Engineering. 10.1109/TSE.2017.2782280. 45:4. (319-334).

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

  • Terragni V, Pezze M and Bianchi F. (2019). Coverage-Driven Test Generation for Thread-Safe Classes via Parallel and Conflict Dependencies 2019 12th IEEE Conference on Software Testing, Validation and Verification (ICST). 10.1109/ICST.2019.00034. 978-1-7281-1736-2. (264-275).

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

  • Aziz A, Unny M, Niranjana S, Sanjana M and Swaminathan J. (2019). Decoding Parallel Program Execution by using Java Interactive Visualization Environment (JIVE): Behavioral and Performance Analysis 2019 3rd International Conference on Computing Methodologies and Communication (ICCMC). 10.1109/ICCMC.2019.8819754. 978-1-5386-7808-4. (792-797).

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

  • Dilley N and Lange J. (2019). An Empirical Study of Messaging Passing Concurrency in Go Projects 2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER). 10.1109/SANER.2019.8668036. 978-1-7281-0591-8. (377-387).

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

  • Nielebock S, Heumüller R and Ortmeier F. (2019). Programmers do not favor lambda expressions for concurrent object-oriented code. Empirical Software Engineering. 24:1. (103-138). Online publication date: 1-Feb-2019.

    https://doi.org/10.1007/s10664-018-9622-9

  • Akiki P. (2018). To var or not to var: how do C# developers use and misuse implicit and explicit typing?. Software Quality Journal. 10.1007/s11219-018-9426-6.

    http://link.springer.com/10.1007/s11219-018-9426-6

  • Terragni V and Pezzè M. Effectiveness and challenges in generating concurrent tests for thread-safe classes. Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering. (64-75).

    https://doi.org/10.1145/3238147.3238224

  • von Nostitz-Wallwitz I, Krüger J and Leich T. Towards improving industrial adoption. Proceedings of the 5th International Workshop on Software Engineering Research and Industrial Practice. (10-17).

    https://doi.org/10.1145/3195546.3195548

  • (2018). Do android developers neglect error handling? a maintenance-Centric study on the relationship between android abstractions and uncaught exceptions. Journal of Systems and Software. 136:C. (1-18). Online publication date: 1-Feb-2018.

    https://doi.org/10.1016/j.jss.2017.10.032

  • Yu F, Zhong H and Shen B. (2017). How Do Programmers Maintain Concurrent Code? 2017 24th Asia-Pacific Software Engineering Conference (APSEC). 10.1109/APSEC.2017.71. 978-1-5386-3681-7. (594-599).

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

  • Pinto G, Canino A, Castor F, Xu G and Liu Y. Understanding and overcoming parallelism bottlenecks in ForkJoin applications. Proceedings of the 32nd IEEE/ACM International Conference on Automated Software Engineering. (765-775).

    /doi/10.5555/3155562.3155657

  • Pinto G, Canino A, Castor F, Xu G and Liu Y. (2017). Understanding and overcoming parallelism bottlenecks in ForkJoin applications 2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE). 10.1109/ASE.2017.8115687. 978-1-5386-2684-9. (765-775).

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

  • Nguyen A, Hilton M, Codoban M, Nguyen H, Mast L, Rademacher E, Nguyen T and Dig D. API code recommendation using statistical learning from fine-grained changes. Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering. (511-522).

    https://doi.org/10.1145/2950290.2950333

  • Liu H, Chen Y and Lu S. Understanding and generating high quality patches for concurrency bugs. Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering. (715-726).

    https://doi.org/10.1145/2950290.2950309

  • Wu D, Chen L, Zhou Y and Xu B. (2016). An extensive empirical study on C++ concurrency constructs. Information and Software Technology. 76:C. (1-18). Online publication date: 1-Aug-2016.

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

  • Terragni V and Cheung S. Coverage-driven test code generation for concurrent classes. Proceedings of the 38th International Conference on Software Engineering. (1121-1132).

    https://doi.org/10.1145/2884781.2884876

  • Kochhar P, Wijedasa D and Lo D. (2016). A Large Scale Study of Multiple Programming Languages and Code Quality 2016 IEEE 23rd International Conference on Software Analysis, Evolution and Reengineering (SANER). 10.1109/SANER.2016.112. 978-1-5090-1855-0. (563-573).

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

  • Bhatia S and Sharma A. (2016). Analysis of Programming Tool for the Development of Software Tool to Improve the Quality of Software Product Using Fuzzy Quality Function Deployment 2016 Second International Conference on Computational Intelligence & Communication Technology (CICT). 10.1109/CICT.2016.11. 978-1-5090-0210-8. (1-5).

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

  • Goncalves R, Amaris M, Okada T, Bruel P and Goldman A. OpenMP is Not as Easy as It Appears. Proceedings of the 2016 49th Hawaii International Conference on System Sciences (HICSS). (5742-5751).

    https://doi.org/10.1109/HICSS.2016.710

  • Okur S. Understanding, refactoring, and fixing concurrency in C#. Proceedings of the 30th IEEE/ACM International Conference on Automated Software Engineering. (898-901).

    https://doi.org/10.1109/ASE.2015.82

  • Dig D. Refactoring for Asynchronous Execution on Mobile Devices. IEEE Software. 10.1109/MS.2015.133. 32:6. (52-61).

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

  • Wu D, Chen L, Zhou Y and Xu B. (2015). An Empirical Study on C++ Concurrency Constructs 2015 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). 10.1109/ESEM.2015.7321187. 978-1-4673-7899-4. (1-10).

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

  • Ertel S, Fetzer C and Felber P. Ohua. Proceedings of the Principles and Practices of Programming on The Java Platform. (51-64).

    https://doi.org/10.1145/2807426.2807431

  • Radoi C and Dig D. (2015). Effective Techniques for Static Race Detection in Java Parallel Loops. ACM Transactions on Software Engineering and Methodology. 24:4. (1-30). Online publication date: 2-Sep-2015.

    https://doi.org/10.1145/2729975

  • Gu R, Jin G, Song L, Zhu L and Lu S. What change history tells us about thread synchronization. Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering. (426-438).

    https://doi.org/10.1145/2786805.2786815

  • Lin Y and Dig D. (2015). A study and toolkit of CHECK-THEN-ACT idioms of Java concurrent collections. Software Testing, Verification & Reliability. 25:4. (397-425). Online publication date: 1-Jun-2015.

    https://doi.org/10.1002/stvr.1567

  • Nanz S and Furia C. A comparative study of programming languages in Rosetta code. Proceedings of the 37th International Conference on Software Engineering - Volume 1. (778-788).

    /doi/10.5555/2818754.2818848

  • Nanz S and Furia C. (2015). A Comparative Study of Programming Languages in Rosetta Code 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering (ICSE). 10.1109/ICSE.2015.90. 978-1-4799-1934-5. (778-788).

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

  • Li K, Reichenbach C, Csallner C and Smaragdakis Y. (2014). Residual Investigation. ACM Transactions on Software Engineering and Methodology. 24:2. (1-32). Online publication date: 23-Dec-2014.

    https://doi.org/10.1145/2656201

  • Lin Y, Radoi C and Dig D. Retrofitting concurrency for Android applications through refactoring. Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. (341-352).

    https://doi.org/10.1145/2635868.2635903

  • De Wael M, Marr S and Van Cutsem T. Fork/join parallelism in the wild. Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java platform: Virtual machines, Languages, and Tools. (39-50).

    https://doi.org/10.1145/2647508.2647511

  • Okur S, Erdogan C and Dig D. Converting Parallel Code from Low-Level Abstractions to Higher-Level Abstractions. Proceedings of the 28th European Conference on ECOOP 2014 --- Object-Oriented Programming - Volume 8586. (515-540).

    https://doi.org/10.1007/978-3-662-44202-9_21

  • Okur S, Hartveld D, Dig D and Deursen A. A study and toolkit for asynchronous programming in c#. Proceedings of the 36th International Conference on Software Engineering. (1117-1127).

    https://doi.org/10.1145/2568225.2568309

  • Marinescu C. An empirical investigation on MPI open source applications. Proceedings of the 18th International Conference on Evaluation and Assessment in Software Engineering. (1-4).

    https://doi.org/10.1145/2601248.2601298

  • Dyer R, Rajan H and Nguyen T. (2013). Declarative visitors to ease fine-grained source code mining with full history on billions of AST nodes. ACM SIGPLAN Notices. 49:3. (23-32). Online publication date: 5-Mar-2014.

    https://doi.org/10.1145/2637365.2517226

  • Marowka A. (2014). Towards Standardization of Measuring the Usability of Parallel Languages. Parallel Processing and Applied Mathematics. 10.1007/978-3-642-55195-6_6. (65-74).

    https://link.springer.com/10.1007/978-3-642-55195-6_6

  • Meyerovich L and Rabkin A. (2013). Empirical analysis of programming language adoption. ACM SIGPLAN Notices. 48:10. (1-18). Online publication date: 12-Nov-2013.

    https://doi.org/10.1145/2544173.2509515

  • Meyerovich L and Rabkin A. Empirical analysis of programming language adoption. Proceedings of the 2013 ACM SIGPLAN international conference on Object oriented programming systems languages & applications. (1-18).

    https://doi.org/10.1145/2509136.2509515

  • Dig D. Invited talk on refactoring. Proceedings of the 2013 ACM workshop on Mobile development lifecycle. (15-16).

    https://doi.org/10.1145/2542128.2542132

  • Dyer R, Rajan H and Nguyen T. Declarative visitors to ease fine-grained source code mining with full history on billions of AST nodes. Proceedings of the 12th international conference on Generative programming: concepts & experiences. (23-32).

    https://doi.org/10.1145/2517208.2517226

  • Pinto G. Refactoring multicore applications towards energy efficiency. Proceedings of the 2013 companion publication for conference on Systems, programming, & applications: software for humanity. (61-64).

    https://doi.org/10.1145/2508075.2508084

  • Teyton C, Falleri J, Morandat F and Blanc X. (2013). Find your library experts 2013 20th Working Conference on Reverse Engineering (WCRE). 10.1109/WCRE.2013.6671295. 978-1-4799-2931-3. (202-211).

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

  • Nanz S, West S, Silveira K and Meyer B. (2013). Benchmarking Usability and Performance of Multicore Languages 2013 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). 10.1109/ESEM.2013.10. 978-0-7695-5056-5. (183-192).

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

  • Nanz S, West S and da Silveira K. Examining the expert gap in parallel programming. Proceedings of the 19th international conference on Parallel Processing. (434-445).

    https://doi.org/10.1007/978-3-642-40047-6_45

  • Schill M, Nanz S and Meyer B. Handling Parallelism in a Concurrency Model. Proceedings of the International Conference on Multicore Software Engineering, Performance, and Tools - Volume 8063. (37-48).

    https://doi.org/10.1007/978-3-642-39955-8_4

  • Gyori A, Franklin L, Dig D and Lahoda J. Crossing the gap from imperative to functional programming through refactoring. Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering. (543-553).

    https://doi.org/10.1145/2491411.2491461

  • Radoi C and Dig D. Practical static race detection for Java parallel loops. Proceedings of the 2013 International Symposium on Software Testing and Analysis. (178-190).

    https://doi.org/10.1145/2483760.2483765

  • Tasharofi S, Dinges P and Johnson R. Why do scala developers mix the actor model with other concurrency models?. Proceedings of the 27th European conference on Object-Oriented Programming. (302-326).

    https://doi.org/10.1007/978-3-642-39038-8_13

  • Franklin L, Gyori A, Lahoda J and Dig D. LAMBDAFICATOR: from imperative to functional programming through automated refactoring. Proceedings of the 2013 International Conference on Software Engineering. (1287-1290).

    /doi/10.5555/2486788.2486986

  • Franklin L, Gyori A, Lahoda J and Dig D. (2013). LambdaFicator: From imperative to functional programming through automated refactoring 2013 35th International Conference on Software Engineering (ICSE). 10.1109/ICSE.2013.6606699. 978-1-4673-3076-3. (1287-1290).

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

  • Lin Y and Dig D. CHECK-THEN-ACT Misuse of Java Concurrent Collections. Proceedings of the 2013 IEEE Sixth International Conference on Software Testing, Verification and Validation. (164-173).

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