Patrick Lam
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Patrick Lam has a total of 15 co-authors. Here are the top co-authors by number of shared publications:
- Karoliine Holter
University of Tartu, Tartu, Estonia
3 shared publications - Simmo Saan
University of Tartu
3 shared publications - Vesal Vojdani
University of Tartu, Tartu, Estonia
3 shared publications - Juhan Oskar Hennoste
University of Tartu, Tartu, Estonia
2 shared publications - Alex Le Blanc
University of Waterloo
1 shared publication - Austin Kothig1 shared publication
Latest Publications
- Open Access
- 15 September 2025
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Programming Languages and Systems
- Vol. 47 (3) , 1-40
Sound Static Data Race Verification for C: Is the Race Lost?
Sound static data race freedom verification has been a long-standing challenge in the field of programming languages. While actively researched a decade ago, most practical data race detection tools have since abandoned soundness. Is sound static race freedom verification for real-world C programs a lost cause? In this work, we investigate the obstacles to making significant progress in automated race freedom verification. We selected a benchmark suite of real-world programs and, as our primary contribution, extracted a set of coding idioms that represent fundamental barriers to verification. We expressed these idioms as micro-benchmarks and contributed them as evaluation tasks for the International Competition on Software Verification, SV-COMP. To understand the current state, we measure how sound automated verification tools competing in SV-COMP perform on these idioms and also when used out of the box on the real-world programs. For 8 of the 20 coding idioms, there does exist an automated race freedom verifier that can verify it; however, we also found significant unsoundness in leading verifiers, including Goblint and Deagle. Five of the seven tools failed to return any result on any real-world benchmarks under our chosen resource limitations, with the remaining two tools verifying race freedom for 2 of the 18 programs and crashing or returning inconclusive results on the others. We thus show that state-of-the-art verifiers have both superficial and fundamental barriers to correctly analyzing real-world programs. These barriers constitute the open problems that must be solved to make progress on automated static data race freedom verification.
- 15 September 2025
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Programming Languages and Systems
- Vol. 47 (3) , 1-40
Open AccessSound Static Data Race Verification for C: Is the Race Lost?
Sound static data race freedom verification has been a long-standing challenge in the field of programming languages. While actively researched a decade ago, most practical data race detection tools have since abandoned soundness. Is sound static race freedom verification for real-world C programs a lost cause? In this work, we investigate the obstacles to making significant progress in automated race freedom verification. We selected a benchmark suite of real-world programs and, as our primary contribution, extracted a set of coding idioms that represent fundamental barriers to verification. We expressed these idioms as micro-benchmarks and contributed them as evaluation tasks for the International Competition on Software Verification, SV-COMP. To understand the current state, we measure how sound automated verification tools competing in SV-COMP perform on these idioms and also when used out of the box on the real-world programs. For 8 of the 20 coding idioms, there does exist an automated race freedom verifier that can verify it; however, we also found significant unsoundness in leading verifiers, including Goblint and Deagle. Five of the seven tools failed to return any result on any real-world benchmarks under our chosen resource limitations, with the remaining two tools verifying race freedom for 2 of the 18 programs and crashing or returning inconclusive results on the others. We thus show that state-of-the-art verifiers have both superficial and fundamental barriers to correctly analyzing real-world programs. These barriers constitute the open problems that must be solved to make progress on automated static data race freedom verification.
- Open Access
- 17 October 2024
- Published by Association for Computing Machinery (ACM)
- p. 130-146
Abstract Debuggers: Exploring Program Behaviors using Static Analysis Results | Proceedings of the 2024 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software
Traditional, or concrete, debuggers allow developers to step through programs and explore the corresponding concrete program states—developers can query current values of program variables. This exploration enables developers to formulate and refine hypotheses about program behaviors. We propose the novel notion of abstract debuggers, which allow developers to explore abstract program states, as computed by sound static analyzers. Giving developers the ability to interactively explore abstract states empowers them to work with hypotheses that are true for all program executions: they can examine and rule out false positives, or better understand a static analysis’s declaration that some code is indeed safe. Abstract debuggers’ interfaces, reminiscent of conventional debuggers, aim to make navigating and interpreting static analysis results more straightforward. We have formalized the concept, applied it by implementing a tool that leverages the static analyzer Goblint, and illustrate its usefulness through case studies.
- 17 October 2024
- Published by Association for Computing Machinery (ACM)
- p. 130-146
Open AccessAbstract Debuggers: Exploring Program Behaviors using Static Analysis Results | Proceedings of the 2024 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software
Traditional, or concrete, debuggers allow developers to step through programs and explore the corresponding concrete program states—developers can query current values of program variables. This exploration enables developers to formulate and refine hypotheses about program behaviors. We propose the novel notion of abstract debuggers, which allow developers to explore abstract program states, as computed by sound static analyzers. Giving developers the ability to interactively explore abstract states empowers them to work with hypotheses that are true for all program executions: they can examine and rule out false positives, or better understand a static analysis’s declaration that some code is indeed safe. Abstract debuggers’ interfaces, reminiscent of conventional debuggers, aim to make navigating and interpreting static analysis results more straightforward. We have formalized the concept, applied it by implementing a tool that leverages the static analyzer Goblint, and illustrate its usefulness through case studies.
- Open Access
Surveying the Rust Verification Landscape
Rust aims to be a safe programming language applicable to systems programming applications. In particular, its type system has strong guardrails to prevent a variety of issues, such as memory safety bugs and data races. However, these guardrails can be sidestepped via the unsafe keyword. unsafe allows certain otherwise-prohibited operations, but shifts the onus of preventing undefined behaviour from the Rust language's compile-time checks to the developer. We believe that tools have a role to play in ensuring the absence of undefined behaviour in the presence of unsafe code. Moreover, safety aside, programs would also benefit from being verified for functional correctness, ensuring that they meet their specifications. In this research proposal, we explore what it means to do Rust verification. Specifically, we explore which properties are worth verifying for Rust; what techniques exist to verify them; and which code is worth verifying. In doing so, we motivate an effort to verify safety properties of the Rust standard library, presenting the relevant challenges along with ideas to address them.
Open AccessSurveying the Rust Verification Landscape
Rust aims to be a safe programming language applicable to systems programming applications. In particular, its type system has strong guardrails to prevent a variety of issues, such as memory safety bugs and data races. However, these guardrails can be sidestepped via the unsafe keyword. unsafe allows certain otherwise-prohibited operations, but shifts the onus of preventing undefined behaviour from the Rust language's compile-time checks to the developer. We believe that tools have a role to play in ensuring the absence of undefined behaviour in the presence of unsafe code. Moreover, safety aside, programs would also benefit from being verified for functional correctness, ensuring that they meet their specifications. In this research proposal, we explore what it means to do Rust verification. Specifically, we explore which properties are worth verifying for Rust; what techniques exist to verify them; and which code is worth verifying. In doing so, we motivate an effort to verify safety properties of the Rust standard library, presenting the relevant challenges along with ideas to address them.
- Open Access
- 13 September 2024
- Published by Association for Computing Machinery (ACM)
- p. 32-33
Abstract Debugging with GobPie | Proceedings of the 2nd ACM International Workshop on Future Debugging Techniques
GobPie is an IDE integration designed to enhance the usability and explainability of the abstract interpretation-based static analyzer Goblint. GobPie features abstract debugging, a novel approach to presenting static analysis results, which complements traditional debugging methods by making program analysis results visible. Its goal is to help resolve rare but real software issues. Unlike traditional debugging, which proceeds step-by-step to observe concrete states, abstract debugging uses static analysis results to simulate the same steps, offering insights into all possible execution paths.
- 13 September 2024
- Published by Association for Computing Machinery (ACM)
- p. 32-33
Open AccessAbstract Debugging with GobPie | Proceedings of the 2nd ACM International Workshop on Future Debugging Techniques
GobPie is an IDE integration designed to enhance the usability and explainability of the abstract interpretation-based static analyzer Goblint. GobPie features abstract debugging, a novel approach to presenting static analysis results, which complements traditional debugging methods by making program analysis results visible. Its goal is to help resolve rare but real software issues. Unlike traditional debugging, which proceeds step-by-step to observe concrete states, abstract debugging uses static analysis results to simulate the same steps, offering insights into all possible execution paths.
- 12 February 2024
- Published by Springer Nature in Empirical Software Engineering
- Vol. 29 (2) , 1-34
A study of common bug fix patterns in Rust
- 12 February 2024
- Published by Springer Nature in Empirical Software Engineering
- Vol. 29 (2) , 1-34
A study of common bug fix patterns in Rust
- Open Access
Exploring the Verifiability of Code Generated by GitHub Copilot
GitHub's Copilot generates code quickly. We investigate whether it generates good code. Our approach is to identify a set of problems, ask Copilot to generate solutions, and attempt to formally verify these solutions with Dafny. Our formal verification is with respect to hand-crafted specifications. We have carried out this process on 6 problems and succeeded in formally verifying 4 of the created solutions. We found evidence which corroborates the current consensus in the literature: Copilot is a powerful tool; however, it should not be "flying the plane" by itself.
Open AccessExploring the Verifiability of Code Generated by GitHub Copilot
GitHub's Copilot generates code quickly. We investigate whether it generates good code. Our approach is to identify a set of problems, ask Copilot to generate solutions, and attempt to formally verify these solutions with Dafny. Our formal verification is with respect to hand-crafted specifications. We have carried out this process on 6 problems and succeeded in formally verifying 4 of the created solutions. We found evidence which corroborates the current consensus in the literature: Copilot is a powerful tool; however, it should not be "flying the plane" by itself.
- Open Access
- 17 November 2020
- Published by Association for Computing Machinery (ACM)
- p. 157-179
Putting the semantics into semantic versioning
The long-standing aspiration for software reuse has made astonishing strides in the past few years. Many modern software development ecosystems now come with rich sets of publicly-available components contributed by the community. Downstream developers can leverage these upstream components, boosting their productivity. However, components evolve at their own pace. This imposes obligations on and yields benefits for downstream developers, especially since changes can be breaking, requiring additional downstream work to adapt to. Upgrading too late leaves downstream vulnerable to security issues and missing out on useful improvements; upgrading too early results in excess work. Semantic versioning has been proposed as an elegant mechanism to communicate levels of compatibility, enabling downstream developers to automate dependency upgrades. While it is questionable whether a version number can adequately characterize version compatibility in general, we argue that developers would greatly benefit from tools such as semantic version calculators to help them upgrade safely. The time is now for the research community to develop such tools: large component ecosystems exist and are accessible, component interactions have become observable through automated builds, and recent advances in program analysis make the development of relevant tools feasible. In particular, contracts (both traditional and lightweight) are a promising input to semantic versioning calculators, which can suggest whether an upgrade is likely to be safe.
- 17 November 2020
- Published by Association for Computing Machinery (ACM)
- p. 157-179
Open AccessPutting the semantics into semantic versioning
The long-standing aspiration for software reuse has made astonishing strides in the past few years. Many modern software development ecosystems now come with rich sets of publicly-available components contributed by the community. Downstream developers can leverage these upstream components, boosting their productivity. However, components evolve at their own pace. This imposes obligations on and yields benefits for downstream developers, especially since changes can be breaking, requiring additional downstream work to adapt to. Upgrading too late leaves downstream vulnerable to security issues and missing out on useful improvements; upgrading too early results in excess work. Semantic versioning has been proposed as an elegant mechanism to communicate levels of compatibility, enabling downstream developers to automate dependency upgrades. While it is questionable whether a version number can adequately characterize version compatibility in general, we argue that developers would greatly benefit from tools such as semantic version calculators to help them upgrade safely. The time is now for the research community to develop such tools: large component ecosystems exist and are accessible, component interactions have become observable through automated builds, and recent advances in program analysis make the development of relevant tools feasible. In particular, contracts (both traditional and lightweight) are a promising input to semantic versioning calculators, which can suggest whether an upgrade is likely to be safe.
- Open Access
- 6 November 2019
- Published by Queen's University Library in Proceedings of the Canadian Engineering Education Association (CEEA)
SOFTWARE ENGINEERING DAYS: USING A VIDEO GAME PLATFORM TO TEACH COLLABORATIVE SOFTWARE DEVELOPMENT
This paper describes the implementation and assessment of a multi-day engineering design activity for Software Engineering students. This activity required students to work in teams of 16 to develop and implement four sub-systems of a digital spaceship. The Unity video game engine with a custom "spaceship sandbox" were used to drive student intrinsic motivation for the task, and to limit the complexity of the spaceship implementation. Student feedback of the activity was captured through a survey given immediately following the second day of the activity, and through a focus group conducted with four students later in the term. The feedback on the activity was largely positive, with teamwork, collaboration, and the software to accomplish it (Git) as major learning outcomes identified by students. Several improvements are planned for the fall 2019 version of the activity based on both instructor observation and student feedback.
- 6 November 2019
- Published by Queen's University Library in Proceedings of the Canadian Engineering Education Association (CEEA)
Open AccessSOFTWARE ENGINEERING DAYS: USING A VIDEO GAME PLATFORM TO TEACH COLLABORATIVE SOFTWARE DEVELOPMENT
This paper describes the implementation and assessment of a multi-day engineering design activity for Software Engineering students. This activity required students to work in teams of 16 to develop and implement four sub-systems of a digital spaceship. The Unity video game engine with a custom "spaceship sandbox" were used to drive student intrinsic motivation for the task, and to limit the complexity of the spaceship implementation. Student feedback of the activity was captured through a survey given immediately following the second day of the activity, and through a focus group conducted with four students later in the term. The feedback on the activity was largely positive, with teamwork, collaboration, and the software to accomplish it (Git) as major learning outcomes identified by students. Several improvements are planned for the fall 2019 version of the activity based on both instructor observation and student feedback.
- Open Access
- 11 June 2010
- Published by Association for Computing Machinery (ACM)
- Vol. 11, 79-88
Role-based access control (RBAC) in Java via proxy objects using annotations
- 11 June 2010
- Published by Association for Computing Machinery (ACM)
- Vol. 11, 79-88
Open AccessRole-based access control (RBAC) in Java via proxy objects using annotations