Patanamon (Pick) Thongtanunam
School of Computing and Information Systems (CIS). The University of Melbourne, Victoria, Australia
Dr. Patanamon Thongtanunam (or Pick) is a Senior Lecturer (equivalent to Associate Professor) at the School of Computing and Information Systems, the University of Melbourne.
Pick’s research interests include empirical software engineering, data mining, and data-driven techniques to support software engineering tasks. Her primary research goals are directed towards uncovering empirical evidence, extracting knowledge from data recorded in software repositories, gleans actionable insights for software engineering management, and developing automated approaches to support developers. Her research work and endeavour has received numerous prestigious awards including an Australian Research Councile (ARC) Discovery Early Career Research Award (2021 - 2024), Japan Society for the Promotion of Science Research Fellowship (2016 - 2018), ACM SIGSOFT Distinguished Paper award, IEEE Computer Society TCSE Distinguished Paper Award, as well as distinguished reviewer awards.
Contact: patanamon{dot}t{at}unimelb.edu.au
Recent Publications
2024
- ISSRECode Ownership: The Principles, Differences, and Their Associations with Software QualityPatanamon Thongtanunam, and Chakkrit TantithamthavornIn Proceedings of the IEEE International Symposium on Software Reliability Engineering, 2024Acceptance rate: 20% (42/2065)
Code ownership-an approximation of the degree of ownership of a software component-is one of the important software measures used in quality improvement plans. However, prior studies proposed different variants of code ownership approximations. Yet, little is known about the difference in code ownership approximations and their association with software quality. In this paper, we investigate the differences in the commonly used ownership approximations (i.e., commit-based and line-based) in terms of the set of developers, the approximated code ownership values, and the expertise level. Then, we analyze the association of each code ownership approximation with the defect-proneness. Through an empirical study of 25 releases that span real-world open-source software systems, we find that commit-based and line-based ownership approximations produce different sets of developers, different code ownership values, and different sets of major developers. In addition, we find that the commit-based approximation has a stronger association with software quality than the line-based approximation. Based on our analysis, we recommend line-based code ownership be used for accountability purposes (e.g., authorship attribution, intellectual property), while commit-based code ownership should be used for rapid bug-fixing and charting quality improvement plans.
@inproceedings{ThongtanunamISSRE2024, bibtex_show = {true}, title = {Code Ownership: The Principles, Differences, and Their Associations with Software Quality}, author = {Thongtanunam, Patanamon and Tantithamthavorn, Chakkrit}, booktitle = {Proceedings of the IEEE International Symposium on Software Reliability Engineering}, abbr = {ISSRE}, pages = {to appear}, year = {2024}, doi = {}, html = {}, note = {Acceptance rate: 20% (42/2065)}, pdf = {https://www.researchgate.net/publication/383310237_Code_Ownership_The_Principles_Differences_and_Their_Associations_with_Software_Quality} } - ISTDon’t forget to change these functions! recommending co-changed functions in modern code reviewYang Hong, Chakkrit Tantithamthavorn, Patanamon Thongtanunam, and Aldeida AletiInformation and Software Technology, 2024
Context: Code review is effective and widely used, yet still time-consuming. Especially, in large-scale software systems, developers may forget to change other related functions that must be changed together (aka. co-changes). This may increase the number of review iterations and reviewing time, thus delaying the code review process. Based on our analysis of 66 projects from five open-source systems, we find that there are 16%–33% of code reviews where at least one function must be co-changed, but was not initially changed. Objectives: This study aims to propose an approach to recommend co-changed functions in the context of modern code review, which could reduce reviewing time and iterations and help developers identify functions that need to be changed together. Methods: We propose CoChangeFinder, a novel method that employs a Graph Neural Network (GNN) to recommend co-changed functions for newly submitted code changes. Then, we conduct a quantitative and qualitative evaluation of CoChangeFinder with 66 studied large-scale open-source software projects. Results: Our evaluation results show that our CoChangeFinder outperforms the state-of-the-art approach, achieving 3.44% to 40.45% for top-k accuracy, 2.00% to 26.07% for Recall@k, and 0.04 to 0.21 for mean average precision better than the baseline approach. In addition, our CoChangeFinder demonstrates the capacity to pinpoint the functions related to logic changes. Conclusion: Our CoChangeFinder outperforms the baseline approach (i.e., TARMAQ) in recommending co-changed functions during the code review process. Based on our findings, CoChangeFinder could help developers save their time and effort, reduce review iterations, and enhance the efficiency of the code review process.
@article{Hong2024IST, bibtex_show = {true}, title = {Don’t forget to change these functions! recommending co-changed functions in modern code review}, author = {Hong, Yang and Tantithamthavorn, Chakkrit and Thongtanunam, Patanamon and Aleti, Aldeida}, journal = {Information and Software Technology}, abbr = {IST}, pages = {to appear}, year = {2024}, doi = {10.1016/j.infsof.2024.107547}, html = {https://www.sciencedirect.com/science/article/pii/S0950584924001526}, pdf = {} } - ISSTAAn Empirical Study of Static Analysis Tools for Secure Code ReviewWachiraphan Charoenwet, Patanamon Thongtanunam, Van-Thuan Pham, and Christoph TreudeIn Proceedings of the ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA), 2024Acceptance rate: 20% (143/694)
Early identification of security issues in software development is vital to minimize their unanticipated impacts. Code review is a widely used manual analysis method that aims to uncover security issues along with other coding issues in software projects. While some studies suggest that automated static application security testing tools (SASTs) could enhance security issue identification, there is limited understanding of SAST’s practical effectiveness in supporting secure code review. Moreover, most SAST studies rely on synthetic or fully vulnerable versions of the subject program, which may not accurately represent real-world code changes in the code review process. To address this gap, we study C/C++ SASTs using a dataset of actual code changes that contributed to exploitable vulnerabilities. Beyond SAST’s effectiveness, we quantify potential benefits when changed functions are prioritized by SAST warnings. Our dataset comprises 319 real-world vulnerabilities from 815 vulnerability-contributing commits (VCCs) in 92 C and C++ projects. The result reveals that a single SAST can produce warnings in vulnerable functions of 52% of VCCs. Prioritizing changed functions with SAST warnings can improve accuracy (i.e., 12% of precision and 5.6% of recall) and reduce Initial False Alarm (lines of code in non-vulnerable functions inspected until the first vulnerable function) by 13%. Nevertheless, at least 76% of the warnings in vulnerable functions are irrelevant to the VCCs, and 22% of VCCs remain undetected due to limitations of SAST rules. Our findings highlight the benefits and the remaining gaps of SAST-supported secure code reviews and challenges that should be addressed in future work.
@inproceedings{CharoenwetSAT2024, bibtex_show = {true}, title = {An Empirical Study of Static Analysis Tools for Secure Code Review}, author = {Charoenwet, Wachiraphan and Thongtanunam, Patanamon and Pham, Van-Thuan and Treude, Christoph}, booktitle = {Proceedings of the ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA)}, abbr = {ISSTA}, pages = {to appear}, year = {2024}, doi = {}, html = {}, note = {Acceptance rate: 20% (143/694)}, pdf = {https://www.researchgate.net/publication/382331847_An_Empirical_Study_of_Static_Analysis_Tools_for_Secure_Code_Review} } - ISSTAVRDSynth: Synthesizing Programs for Multilingual Visually Rich Document Information ExtractionThanh-Dat Nguyen, Tung Do-Viet, Hung Nguyen-Duy, Tuan-Hai Luu, Hung Le, and 2 more authorsIn Proceedings of the ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA), 2024Acceptance rate: 20% (143/694)
Businesses need to query visually rich documents (VRDs) like receipts, medical records, and insurance forms to make decisions. Existing techniques for extracting entities from VRDs struggle with new layouts or require extensive pre-training data. We introduce VRDSynth, a program synthesis method to automatically extract entity relations from multilingual VRDs without pre-training data. To capture the complexity of VRD domain, we design a domain-specific language (DSL) to capture spatial and textual relations to describe the synthesized programs. Along with this, we also derive a new synthesis algorithm utilizing frequent spatial relations, search space pruning, and a combination of positive, negative, and exclusive programs to improve coverage. We evaluate VRDSynth on the FUNSD and XFUND benchmarks for semantic entity linking, consisting of 1,592 forms in 8 languages. VRDSynth outperforms state-of-the-art pre-trained models (LayoutXLM, InfoXLMBase, and XLMRobertaBase) in 5, 6, and 7 out of 8 languages, respectively, improving the F1 score by 42% over LayoutXLM in English. To test the extensibility of the model, we further improve VRDSynth with automated table recognition, creating VRDSynth(Table), and compare it with extended versions of the pre-trained models, InfoXLM(Large) and XLMRoberta(Large). VRDSynth(Table) outperforms these baselines in 4 out of 8 languages and in average F1 score. VRDSynth also significantly reduces memory footprint (1M and 380MB vs. 1.48GB and 3GB for LayoutXLM) while maintaining similar time efficiency.
@inproceedings{Nguyen2024, bibtex_show = {true}, title = {VRDSynth: Synthesizing Programs for Multilingual Visually Rich Document Information Extraction}, author = {Nguyen, Thanh-Dat and Do-Viet, Tung and Nguyen-Duy, Hung and Luu, Tuan-Hai and Le, Hung and Le, Bach and Thongtanunam, Patanamon}, booktitle = {Proceedings of the ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA)}, abbr = {ISSTA}, pages = {to appear}, year = {2024}, doi = {}, html = {}, note = {Acceptance rate: 20% (143/694)}, pdf = {https://www.researchgate.net/publication/382111678_VRDSynth_Synthesizing_Programs_for_Multilingual_Visually_Rich_Document_Information_Extraction} } - TOSEMAutomatically Recommend Code Updates: Are We There Yet?Yue Liu, Chakkrit Tantithamthavorn, Yonghui Liu, Patanamon Thongtanunam, and Li LiACM Transactions on Software Engineering and Methodology, 2024
In recent years, large pre-trained Language Models of Code (CodeLMs) have shown promising results on various software engineering tasks. One such task is automatic code update recommendation, which transforms outdated code snippets into their approved and revised counterparts. Although many CodeLM-based approaches have been proposed, claiming high accuracy, their effectiveness and reliability on real-world code update tasks remain questionable. In this paper, we present the first extensive evaluation of state-of-the-art CodeLMs for automatically recommending code updates. We assess their performance on two diverse datasets of paired updated methods, considering factors such as temporal evolution, project specificity, method size, and update complexity. Our results reveal that while CodeLMs exhibit higher performance in settings that ignore temporal information, they struggle in more realistic time-wise scenarios and generalize poorly to new projects. Furthermore, CodeLM performance decreases significantly for larger methods and more complex updates. Furthermore, we observe that many CodeLM-generated “updates” are actually null, especially in time-wise settings, and meaningful edits remain challenging. Our findings highlight the significant gap between the perceived and actual effectiveness of CodeLMs for real-world code update recommendation and emphasize the need for more research on improving their practicality, robustness, and generalizability.
@article{Lyu2024, bibtex_show = {true}, title = {Automatically Recommend Code Updates: Are We There Yet?}, author = {Liu, Yue and Tantithamthavorn, Chakkrit and Liu, Yonghui and Thongtanunam, Patanamon and Li, Li}, journal = {ACM Transactions on Software Engineering and Methodology}, abbr = {TOSEM}, pages = {to appear}, year = {2024}, doi = {}, html = {}, pdf = {https://www.researchgate.net/publication/382307804_Automatically_Recommend_Code_Updates_Are_We_There_Yet} } - EMSEToward Effective Secure Code Reviews: An Empirical Study of Security-Related Coding WeaknessesWachiraphan Charoenwet, Patanamon Thongtanunam, Van-Thuan Pham, and Christoph TreudeSpringer Journal of Empirical Software Engineering, 2024
Identifying security issues early is encouraged to reduce the latent negative impacts on software systems. Code review is a widely-used method that allows developers to manually inspect modified code, catching security issues during a software development cycle. However, existing code review studies often focus on known vulnerabilities, neglecting coding weaknesses, which can introduce real-world security issues that are more visible through code review. The practices of code reviews in identifying such coding weaknesses are not yet fully investigated. To better understand this, we conducted an empirical case study in two large open-source projects, OpenSSL and PHP. Based on 135,560 code review comments, we found that reviewers raised security concerns in 35 out of 40 coding weakness categories. Surprisingly, some coding weaknesses related to past vulnerabilities, such as memory errors and resource management, were discussed less often than the vulnerabilities. Developers attempted to address raised security concerns in many cases (39%-41%), but a substantial portion was merely acknowledged (30%-36%), and some went unfixed due to disagreements about solutions (18%-20%). This highlights that coding weaknesses can slip through code review even when identified. Our findings suggest that reviewers can identify various coding weaknesses leading to security issues during code reviews. However, these results also reveal shortcomings in current code review practices, indicating the need for more effective mechanisms or support for increasing awareness of security issue management in code reviews.
@article{Charoenwet2024, bibtex_show = {true}, title = {Toward Effective Secure Code Reviews: An Empirical Study of Security-Related Coding Weaknesses}, author = {Charoenwet, Wachiraphan and Thongtanunam, Patanamon and Pham, Van-Thuan and Treude, Christoph}, journal = {Springer Journal of Empirical Software Engineering}, abbr = {EMSE}, pages = {to appear}, year = {2024}, doi = {}, html = {}, pdf = {https://www.researchgate.net/publication/380732962_Toward_Effective_Secure_Code_Reviews_An_Empirical_Study_of_Security-Related_Coding_Weaknesses} } - TOSEMAutomatic Programming: Large Language Models and BeyondMichael R Lyu, Baishakhi Ray, Abhik Roychoudhury, Shin Hwei Tan, and Patanamon ThongtanunamACM Transactions on Software Engineering and Methodology, 2024
Automatic programming has seen increasing popularity due to the emergence of tools like GitHub Copilot which rely on Large Language Models (LLMs). At the same time, automatically generated code faces challenges during deployment due to concerns around quality and trust. In this article, we study automated coding in a general sense and study the concerns around code quality, security and related issues of programmer responsibility. These are key issues for organizations while deciding on the usage of automatically generated code. We discuss how advances in software engineering such as program repair and analysis can enable automatic programming. We conclude with a forward looking view, focusing on the programming environment of the near future, where programmers may need to switch to different roles to fully utilize the power of automatic programming. Automated repair of automatically generated programs from LLMs, can help produce higher assurance code from LLMs, along with evidence of assurance
@article{Lyu2025, bibtex_show = {true}, title = {Automatic Programming: Large Language Models and Beyond}, author = {Lyu, Michael R and Ray, Baishakhi and Roychoudhury, Abhik and Tan, Shin Hwei and Thongtanunam, Patanamon}, journal = {ACM Transactions on Software Engineering and Methodology}, abbr = {TOSEM}, pages = {to appear}, year = {2024}, doi = {}, html = {}, pdf = {https://arxiv.org/pdf/2405.02213} } - Comp. SurveyA Systematic Literature Review on Reasons and Approaches for Accurate Effort Estimations in AgileJirat Pasuksmit, Patanamon Thongtanunam, and Shanika KarunasekeraACM Computing Surveys, 2024
Background: Accurate effort estimation is crucial for planning in Agile iterative development. Agile estimation generally relies on consensus-based methods like planning poker, which require less time and information than other formal methods (e.g., COSMIC) but are prone to inaccuracies. Understanding the common reasons for inaccurate estimations and how proposed approaches can assist practitioners is essential. However, prior systematic literature reviews (SLR) only focus on the estimation practices (e.g., [26, 127]) and the effort estimation approaches (e.g., [6]). Aim: We aim to identify themes of reasons for inaccurate estimations and classify approaches to improve effort estimation. Method: We conducted an SLR and identified the key themes and a taxonomy. Results: The reasons for inaccurate estimation are related to information quality, team, estimation practice, project management, and business influences. The effort estimation approaches were the most investigated in the literature, while only a few aim to support the effort estimation process. Yet, few automated approaches are at risk of data leakage and indirect validation scenarios. Recommendations: Practitioners should enhance the quality of information for effort estimation, potentially by adopting an automated approach. Future research should aim to improve the information quality, while avoiding data leakage and indirect validation scenarios.
@article{Pasuksmit2024, bibtex_show = {true}, title = {A Systematic Literature Review on Reasons and Approaches for Accurate Effort Estimations in Agile}, author = {Pasuksmit, Jirat and Thongtanunam, Patanamon and Karunasekera, Shanika}, journal = {ACM Computing Surveys}, abbr = {Comp. Survey}, pages = {to appear}, year = {2024}, doi = {}, html = {https://dl.acm.org/doi/abs/10.1145/3663365}, pdf = {https://www.researchgate.net/publication/380274569_A_Systematic_Literature_Review_on_Reasons_and_Approaches_for_Accurate_Effort_Estimations_in_Agile} } - FSEPractitioners’ Challenges and Perceptions of CI Build Failure Predictions at AtlassianYang Hong, Chakkrit Tantithamthavorn, Jirat Pasuksmit, Patanamon Thongtanunam, Arik Friedman, and 2 more authorsIn Proceedings of the ACM International Conference on the Foundations of Software Engineering (FSE), 2024
Continuous Integration (CI) build failures could significantly impact the software development process and teams, such as delaying the release of new features and reducing developers’ productivity. In this work, we report on an empirical study that investigates CI build failures throughout product development at Atlassian. Our quantitative analysis found that the repository dimension is the key factor influencing CI build failures. In addition, our qualitative survey revealed that Atlassian developers perceive CI build failures as challenging issues in practice. Furthermore, we found that the CI build prediction can not only provide proactive insight into CI build failures but also facilitate the team’s decision-making. Our study sheds light on the challenges and expectations involved in integrating CI build prediction tools into the Bitbucket environment, providing valuable insights for enhancing CI processes.
@inproceedings{Hong2024, bibtex_show = {true}, title = {Practitioners' Challenges and Perceptions of CI Build Failure Predictions at Atlassian}, author = {Hong, Yang and Tantithamthavorn, Chakkrit and Pasuksmit, Jirat and Thongtanunam, Patanamon and Friedman, Arik and Zhao, Xing and Krasikov, Anton}, booktitle = {Proceedings of the ACM International Conference on the Foundations of Software Engineering (FSE)}, abbr = {FSE}, pages = {to appear}, year = {2024}, doi = {}, html = {}, pdf = {https://arxiv.org/pdf/2402.09651} } - MSRCurated Email-Based Code Reviews DatasetsMingzhao Liang, Wachiraphan Charoenwet, and Patanamon ThongtanunamIn Proceedings of the IEEE/ACM International Conference on Mining Software Repositories, 2024
Code review is an important practice that improves the overall quality of a proposed patch (i.e. code changes). While much research focused on tool-based code reviews (e.g. a Gerrit code review tool, GitHub), many traditional open-source software (OSS) projects still conduct code reviews through emails. However, due to the nature of unstructured email-based data, it can be challenging to mine email-based code reviews, hindering researchers from delving into the code review practice of such long-standing OSS projects. Therefore , this paper presents large-scale datasets of email-based code reviews of 167 projects across three OSS communities (i.e. Linux Kernel, OzLabs, and FFmpeg). We mined the data from Patchwork, a web-based patch-tracking system for email-based code review, and curated the data by grouping a submitted patch and its revised versions and grouping email aliases. Our datasets include a total of 4.2M patches with 2.1M patch groups and 169K email addresses belonging to 141K individuals. Our published artefacts include the datasets as well as a tool suite to crawl, curate, and store Patchwork data. With our datasets, future work can directly delve into an email-based code review practice of large OSS projects without additional effort in data collection and curation.
@inproceedings{Liang2024, bibtex_show = {true}, title = {Curated Email-Based Code Reviews Datasets}, author = {Liang, Mingzhao and Charoenwet, Wachiraphan and Thongtanunam, Patanamon}, booktitle = {Proceedings of the IEEE/ACM International Conference on Mining Software Repositories}, abbr = {MSR}, pages = {to appear}, year = {2024}, doi = {}, html = {}, pdf = {https://www.researchgate.net/publication/378711871_Curated_Email-Based_Code_Reviews_Datasets} } - MSRImproving Automated Code Reviews: Learning from ExperienceHong Yi Lin, Patanamon Thongtanunam, Christoph Treude, and Wachiraphan CharoenwetIn Proceedings of the IEEE/ACM International Conference on Mining Software Repositories, 2024
Modern code review is a critical quality assurance process that is widely adopted in both industry and open source software environments. This process can help newcomers learn from the feedback of experienced reviewers; however, it often brings a large workload and stress to reviewers. To alleviate this burden, the field of automated code reviews aims to automate the process, teaching large language models to provide reviews on submitted code, just as a human would. A recent approach pre-trained and fine-tuned the code intelligent language model on a large-scale code review corpus. However, such techniques did not fully utilise quality reviews amongst the training data. Indeed, reviewers with a higher level of experience or familiarity with the code will likely provide deeper insights than the others. In this study, we set out to investigate whether higher-quality reviews can be generated from automated code review models that are trained based on an experience-aware oversampling technique. Through our quantitative and qualitative evaluation, we find that experience-aware oversampling can increase the correctness, level of information, and meaningfulness of reviews generated by the current state-of-the-art model without introducing new data. The results suggest that a vast amount of high-quality reviews are underutilised with current training strategies. This work sheds light on resource-efficient ways to boost automated code review models.
@inproceedings{Lin2024, bibtex_show = {true}, title = {Improving Automated Code Reviews: Learning from Experience}, author = {Lin, Hong Yi and Thongtanunam, Patanamon and Treude, Christoph and Charoenwet, Wachiraphan}, booktitle = {Proceedings of the IEEE/ACM International Conference on Mining Software Repositories}, abbr = {MSR}, pages = {to appear}, year = {2024}, doi = {}, html = {}, pdf = {https://www.researchgate.net/publication/378711858_Improving_Automated_Code_Reviews_Learning_from_Experience} } - MSREncoding Version History Context for Better Code RepresentationHuy Nguyen, Christoph Treude, and Patanamon ThongtanunamIn Proceedings of the IEEE/ACM International Conference on Mining Software Repositories, 2024
With the exponential growth of AI tools that generate source code, understanding software has become crucial. When developers comprehend a program, they may refer to additional contexts to look for information, e.g. program documentation or historical code versions. Therefore, we argue that encoding this additional contextual information could also benefit code representation for deep learning. Recent papers incorporate contextual data (e.g. call hierarchy) into vector representation to address program comprehension problems. This motivates further studies to explore additional contexts, such as version history, to enhance models’ understanding of programs. That is, insights from version history enable recognition of patterns in code evolution over time, recurring issues, and the effectiveness of past solutions. Our paper presents preliminary evidence of the potential benefit of encoding contextual information from the version history to predict code clones and perform code classification. We experiment with two representative deep learning models, ASTNN and CodeBERT, to investigate whether combining additional contexts with different aggregations may benefit downstream activities. The experimental result affirms the positive impact of combining version history into source code representation in all scenarios; however, to ensure the technique performs consistently, we need to conduct a holistic investigation on a larger code base using different combinations of contexts, aggregation, and models. Therefore, we propose a research agenda aimed at exploring various aspects of encoding additional context to improve code representation and its optimal utilisation in specific situations.
@inproceedings{Nguyen2025, bibtex_show = {true}, title = {Encoding Version History Context for Better Code Representation}, author = {Nguyen, Huy and Treude, Christoph and Thongtanunam, Patanamon}, booktitle = {Proceedings of the IEEE/ACM International Conference on Mining Software Repositories}, abbr = {MSR}, pages = {to appear}, year = {2024}, doi = {}, html = {}, pdf = {https://www.researchgate.net/publication/378711698_Encoding_Version_History_Context_for_Better_Code_Representation} }
Recent Funding
- 1,200,000 AUDCo-leading the Responsible AI Software Engineering (RAISE) program with 9 industry partners to train 11 graduates (7 Ph.D., 1 Master, and 3 Honours) addressing the urgent need for deep expertise and excellent skills in Responsible AI Software Engineering for digital health, transportation, and defence sectors.402,000 AUDFor 3 years (2021 - )ARC DECRA Fellowship is the competitive fund which is awarded to Early Career Researchers in Australia to support excellent basic and applied research. Success rate (DE21): 200/1173 (17.1%) across all disciplines; 56/331 (16.9%) for the Engineering, Information and Computing Sciences discipline.
Recent Awards
- MSR 2024 Ric Holt Early Career Achievement AwardFor their contributions to understanding and improving modern code review practices using mining software repositories techniques.CIS Excellence in Teaching & Education award (2023)For the outstanding leadership and service in the coordination of Master of Software Engeering program at the School of Computing and Information Systems, The University of MelbourneCIS Excellence in Engagement (ECR) award (2022)For the outstanding research achievements of Early Career Researchers at the School of Computing and Information Systems, The University of Melbourne