publications | Coen De Roover

analysis program code application language software library tool change test abstract pattern static feature information execution source code testing implementation web package projects query static analysis dependency framework model dynamic programming state api interpreter ecosystem performance semantic security image design java support webassembly logic role smell algorithm modular javascript development ansible systems slicing data vulnerabilities control detect function machine contract automated variant evolution template incremental mining extension web applications versions stack object repositories network open-source history empirical detection snippets scala smalltalk usage engineering docker interpretation scheme slices value maven properties reusable compilation bugs maintenance concrete implementing annotations expressions evaluation processes querying method concolic refactoring pointcut information flow behavioral transformation resilience documentation run-time parallel software ecosystem verification garbage interactions infrastructure distributed platform higher-order reuse technology dataset code snippets collection open gui type general-purpose store npm runtime management software engineering symbolic execution stack overflow inheritance path asm developing soft actions improve regular jit event-driven detecting practices merging interface identifying matching executable maintaining github lifuso instantiation machine learning modular analyses semantic versioning sensor actor gasr compiler abstract interpretation security vulnerabilities program analysis property-based declarative abstractions diffusion reasoning posts unification risk domain-specific tree adoption fault debugging docker hub program slicing flow control code analysis program query plugin similarity balancing prevalence variables object-oriented definitional maf problems taxonomy speed nodes suite middleware tierless whole-program representation rubygems

Click a keyword to show only the publications whose abstract mentions it. Click it again to reset.

Conference Papers

2026

An Empirical Study of Policy as Code: Adoption, Purpose, and Maintenance

Ruben Opdebeeck, Mahmoud Alfadel, Akond Rahman, and 4 more authors

In Proceedings of the 23rd International Conference on Mining Software Repositories (MSR), Apr 2026

Abs DOI Bib PDF

Policy as Code (PaC) is an emerging DevOps practice that enables teams to specify organisational and technical policies, such as reg- ulatory compliance, security requirements, and resource limits, through machine-enforceable declarative code. As PaC gains promi- nence, practitioners face difficulties in adopting PaC while there remains a limited empirical understanding of how these policies are introduced, what types can be expressed, and how they are maintained in practice. This paper aims to address this gap through an empirical study of PaC based on 10,560 PaC files from 499 open-source repositories spanning nine PaC tools. We find that PaC is introduced throughout all phases of repository lifecycles, often co-occurring with IaC tools such as Kubernetes or Terraform, with most repositories adopt- ing one of five policy enforcement strategies. Our taxonomy of 12 policy categories reveals that while most policies govern infras- tructures and security requirements, they can also express broader constraints related to software development, intellectual property, and expenses. We observe that PaC files are maintained through infrequent yet often substantial changes. Most changes concern refactoring, yet when policy behaviour does change, policies tend to become stricter rather than more lenient. These findings motivate and support wider and earlier adoption of PaC tools. To this end, the taxonomy of policy categories can serve as a reference to practitioners to identify use cases for PaC in their projects. Meanwhile, our catalogue of enforcement strategies, co-occurring IaC tools, and PaC tool coverage of the taxonomy can inform practitioners when deciding which PaC tool to adopt and This work is licensed under a Creative Commons Attribution 4.0 International License. MSR ’26, Rio de Janeiro, Brazil © 2026 Copyright held by the owner/author(s). ACM ISBN 979-8-4007-2474-9/2026/04 https://doi.org/10.1145/3793302.3793355 how to integrate it in their projects. Finally, our findings motivate future research to automate PaC file generation and maintenance.
@inproceedings{Opdebeeck2026Empirical, series = {MSR ’26}, title = {An Empirical Study of Policy as Code: Adoption, Purpose, and Maintenance}, url = {http://dx.doi.org/10.1145/3793302.3793355}, doi = {10.1145/3793302.3793355}, booktitle = {Proceedings of the 23rd International Conference on Mining Software Repositories (MSR)}, publisher = {ACM}, author = {Opdebeeck, Ruben and Alfadel, Mahmoud and Rahman, Akond and Kashiwa, Yutaro and Ferreira, João F. and Kula, Raula Gaikovina and De Roover, Coen}, year = {2026}, month = apr, pages = {249–261}, collection = {MSR ’26} }
Smarter, but Not Safer: An Empirical Analysis of the Functional-Security Gap in Evolving LLMs

Alfonso Cannavale, Gilberto Recupito, Coen De Roover, and 2 more authors

In Proceedings of the 42nd IEEE International Conference on Software Maintenance and Evolution (ICSME 2026), 2026

Abs Bib PDF

Large Language Models (LLMs) have become tools for software development and maintenance, demonstrating im- pressive capabilities in automating tasks such as code genera- tion and refactoring. However, it remains empirically unclear whether the rapid scaling of these capabilities is accompanied by proportional improvements in security, or whether a discrep- ancy, defined as the Security–Functionality Gap, persists across model generations. To address this question, we conducted an evolutionary study analyzing the trajectory of 12 state-of-the- art models across the GPT, Llama, and Claude Sonnet lineages. By leveraging an outcome-driven benchmark based on dynamic execution, we quantified the divergence between the models’ ability to generate functionally correct code versus secure code over four sequential versions per lineage. Results reveal that, while functional correctness has effectively plateaued (> 90%) across all families, functional-security correctness has evolved more slowly. Specifically, while proprietary models demonstrate marginal improvements, open-weight models exhibit stagnation, and the most advanced models occasionally introduce new regres- sions due to increased code complexity. These findings suggest that security alignment is not an intrinsic byproduct of model scaling, highlighting the urgent need for external guardrails in AI-assisted maintenance pipelines.
@inproceedings{Cannavale2026Smarter, title = {Smarter, but Not Safer: An Empirical Analysis of the Functional-Security Gap in Evolving LLMs}, author = {Cannavale, Alfonso and Recupito, Gilberto and {De Roover}, Coen and Palomba, Fabio and {De Lucia}, Andrea}, booktitle = {Proceedings of the 42nd IEEE International Conference on Software Maintenance and Evolution (ICSME 2026)}, year = {2026}, }
On the Evolution of Python Test Cases into Property-based Tests

Cindy Wauters, Ruben Opdebeeck, and Coen De Roover

In 2026 IEEE International Conference on Software Testing, Verification and Validation (ICST), May 2026

Abs DOI Bib PDF

Conventionally, unit tests exercise their unit under test on predetermined input to validate its behavior. The advent of property-based testing frameworks has led to unit tests that exercise the unit under test on randomly-generated inputs, for which the unit’s behavior has to satisfy developer-specified invariant properties. The promise of increased coverage and stronger validation may lead developers to evolve existing conventional unit tests into property-based ones. This paper reports on the results of an empirical study of 257 property-based unit tests (PBT) from 64 open source repositories that have evolved from a conventional unit test. The study examines each PBT-introducing commit for change patterns, and for the type of features of property-based testing frameworks that are adopted. Next, it investigates the impact of PBT adoption by running test cases to compute changes in code coverage and test failures. Finally, the study investigates the evolution of the newly-introduced PBT by comparing its first to its most recent version. The study’s findings include that 37 out of 257 evolutions required no changes to the body of the test. When changes are required, these are most likely to target setup code followed by oracle code. Over half of the studied PBTs use off-the-shelf input generators, yet see an improvement in code coverage by an average of 4 statements. Additionally, for 5 test cases, the PBT found a counterexample where the original unit test passed. Finally, 80% of the evolved test cases are still present in the current version of the project.
@inproceedings{Wauters2026Evolution, doi = {10.1109/icst69053.2026.00062}, title = {On the Evolution of Python Test Cases into Property-based Tests}, keywords = {empirical study, code coverage, property- based testing, software testing}, author = {Wauters, Cindy and Opdebeeck, Ruben and {De Roover}, Coen}, year = {2026}, month = may, language = {English}, pages = {429--440}, booktitle = {2026 IEEE International Conference on Software Testing, Verification and Validation (ICST)}, publisher = {IEEE}, edition = {19}, url = {https://conf.researchr.org/home/icst-2026} }
Language-Agnostic Detection of Computation-Constraint Inconsistencies in ZKP Programs via Value Inference

Arman Kolozyan, Bram Vandenbogaerde, Janwillem Swalens, and 3 more authors

In 2026 IEEE Symposium on Security and Privacy (S&P), 2026

Abs DOI Bib PDF

Zero-knowledge proofs (ZKPs) allow a prover to convince a verifier of a statement’s truth without revealing any other information. In recent years, ZKPs have matured into a practical technology underpinning major applications. However, implementing ZKP programs remains challenging, as they operate over arithmetic circuits that encode the logic of both the prover and the verifier. Therefore, developers must not only express the computations for generating proofs, but also explicitly specify the constraints for verification. As recent studies have shown, this decoupling may lead to critical ZKP-specific vulnerabilities. Unfortunately, existing tools for detecting them are limited, as they: (1) are tightly coupled to specific ZKP languages, (2) are confined to the constraint level, preventing reasoning about the underlying computations, (3) target only a narrow class of bugs, and (4) suffer from scalability bottlenecks due to reliance on SMT solvers. To address these limitations, we propose a language-agnostic formal model, called the Domain Consistency Model (DCM), which captures the relationship between computations and constraints. Using this model, we provide a taxonomy of vulnerabilities based on computation-constraint mismatches, including novel subclasses overlooked by existing models. Next, we implement an IR-based bug detection tool, called CCC-Check, which is based on abstract interpretation. Our evaluation shows that CCC-Check is, on average, two orders of magnitude faster than the SoTA verification tool CIVER, while achieving comparable precision. Finally, using the DCM, we examine six widely adopted ZKP projects and uncover 15 previously unknown vulnerabilities. We reported these bugs to the projects’ maintainers, 13 of which have since been patched. Of these 15 vulnerabilities, 12 could not be captured by existing models.
@inproceedings{Kolozyan2026Language, doi = {10.1109/sp63933.2026.00207}, title = {Language-Agnostic Detection of Computation-Constraint Inconsistencies in ZKP Programs via Value Inference}, author = {Kolozyan, Arman and Vandenbogaerde, Bram and Swalens, Janwillem and Hoste, Lode and Chaliasos, Stefanos and {De Roover}, Coen}, year = {2026}, language = {English}, isbn = {979-8-3315-6065-2}, pages = {2487--2506}, booktitle = {2026 IEEE Symposium on Security and Privacy (S&P)}, publisher = {IEEE} }

2025

Delta Store Semantics: Abstract Garbage Collection for Abstract Definitional Interpreters

Noah Van Es, Bram Vandenbogaerde, and Coen De Roover

In Static Analysis (SAS), Oct 2025

Abs DOI Bib PDF

Garbage Collection for Abstract Definitional Interpreters Noah Van Es , Bram Vandenbogaerde , and Coen De Roover Vrije Universiteit Brussel, Belgium noah.van.es, bram.vandenbogaerde, coen.de.roover@vub.be Abstract. Both the precision and performance of abstract interpreters can be improved greatly through the integration of abstract garbage collection (GC). Unfortunately, for abstract interpreters that do not explicitly model the stack (e.g., abstract definitional interpreters), this integration has proven cumbersome. Existing approaches either fail to exploit the full precision and performance benefits of abstract GC and pushdown control flow, and/or require complicated modifications to the abstract interpreter. In addition, the lack of global store widening, which is incompatible with abstract GC, often remains an obstacle for scalability. In this work, we present delta store semantics (DSS), offering a novel yet simple approach to integrate abstract GC into big-step abstract definitional interpreters. DSS makes a simple change to the standard big-step language semantics, returning a delta store (representing changes to the original store) instead of an updated store, enabling the integration of a single evaluation rule to interleave GC into its semantics. Importantly, we show that DSS not only preserves the advantages of big-step abstract interpreters and abstract GC, but in fact can exploit greater precision benefits (due to more aggressive GC). We formulate this claim as a theorem, for which we provide both a mechanised proof in Rocq, as well as empirical evidence. Finally, we propose a new form of store widening for DSS, which tackles the scalability issues of abstract interpreters employing abstract GC without store widening. The result is similar to the traditional notion of flow sensitivity in data-flow analyses.
@incollection{VanEs2025Delta, title = {Delta Store Semantics: Abstract Garbage Collection for Abstract Definitional Interpreters}, isbn = {9783032071064}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-032-07106-4_16}, doi = {10.1007/978-3-032-07106-4_16}, booktitle = {Static Analysis (SAS)}, publisher = {Springer Nature Switzerland}, author = {Van Es, Noah and Vandenbogaerde, Bram and De Roover, Coen}, year = {2025}, month = oct, pages = {386–421} }
Handling Cyclic Reinforcement of Lattice Values in Incremental Dependency-driven Static Analysis

Jens Plas, Quentin Stiévenart, and Coen De Roover

In 2025 IEEE International Conference on Source Code Analysis & Manipulation (SCAM), Sep 2025

Abs DOI Bib PDF

Nowadays, many developers heavily rely on feedback from bug-detection tools to help ensure the quality of the code they produce. Such tools are underlain by static analysis. It is, however, critical for analysis results to be produced fast. To this end, incremental static analysis can be used. Upon a program change, an incremental analysis updates the previous results rather than recomputing the results from scratch. Incremental static analyses may suffer from cyclic reinforcement of lattice values, where the computation of some values within the analysis relies on the values themselves, due to the abstractions made by the analysis. This can cause the incremental analysis to produce less precise results, reducing its usability. In this work, we provide a solution to cyclic reinforcement of lattice values for incremental dependency-driven analyses. We compute the information flow within the analysis and show how this information flow can be used to detect cyclic reinforcements. We establish a criterion to detect when a cyclic reinforcement contains outdated information that needs to be removed, and show how precision can be regained. Our results show that using our method, an incremental analysis produces results matching a from-scratch analysis for all but one benchmark program, at the cost of a performance hit in some cases.
@inproceedings{VanderPlas2025Handling, title = {Handling Cyclic Reinforcement of Lattice Values in Incremental Dependency-driven Static Analysis}, url = {http://dx.doi.org/10.1109/SCAM67354.2025.00009}, doi = {10.1109/scam67354.2025.00009}, booktitle = {2025 IEEE International Conference on Source Code Analysis &amp; Manipulation (SCAM)}, publisher = {IEEE}, author = {Van der Plas, Jens and Stiévenart, Quentin and De Roover, Coen}, year = {2025}, month = sep, pages = {13–24} }
Abstracting Concolic Execution for Soft Contract Verification

Bram Vandenbogaerde, Quentin Stiévenart, and Coen De Roover

In Static Analysis (SAS), Oct 2025

Abs DOI Bib PDF

Design-by-contract programming is a best practice in which a contract is used to specify the expected behavior of program elements such as functions and classes. Although enforcing compliance with these contracts at run time renders a program robust against unexpected fail- ures, they also introduce a substantial contract monitoring overhead. Soft contract verification intends to reduce this overhead by verifying as many contracts as possible through static analysis. Thus far, the static analyses underlying existing soft contract verifiers have been based on adaptations of the AAM technique for CESK machines. Intended solely to introduce the concept of soft contract verification, these purpose-built analyses lack configurability. In this paper, we propose a novel static analysis for soft contract verification called abstract concolic execution. We systematically abstract a concolic execution, which is a form of dy- namic symbolic execution, into abstract concolic execution, rendering the technique terminating and sound for any program input. To show that our analysis is more configurable than the state-of-the-art analy- sis supporting soft contract verification, we propose two variations of the analysis. Finally, we show that our approach is comparable to if not more precise than the state of the art at the cost of performance. We find that in 10 out of the 24 benchmark programs, our approach is more precise than the state-of-the-art approach, while being as precise in 9 of them and less precise in 5.
@incollection{Vandenbogaerde2025Abstracting, title = {Abstracting Concolic Execution for Soft Contract Verification}, isbn = {9783032071064}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-032-07106-4_9}, doi = {10.1007/978-3-032-07106-4_9}, booktitle = {Static Analysis (SAS)}, publisher = {Springer Nature Switzerland}, author = {Vandenbogaerde, Bram and Stiévenart, Quentin and De Roover, Coen}, year = {2025}, month = oct, pages = {190–220} }
Monarch: A Modular Framework for Abstract Definitional Interpreters in Haskell

Bram Vandenbogaerde, Sarah Verbelen, Noah Van Es, and 1 more author

In Static Analysis (SAS), Oct 2025

Abs DOI Bib PDF

Definitional Interpreters in Haskell Bram Vandenbogaerde , Sarah Verbelen, Noah Van Es , and Coen De Roover bram.vandenbogaerde, sarah.verbelen, noah.van.es, coen.de.roover@vub.be Vrije Universiteit Brussel, Brussels, Belgium Abstract. Abstract definitional interpreters are an approach to devel- oping abstract interpretation-based static analyses in which language semantics are expressed through monadic recursive interpreters. These interpreters are then instantiated with an abstract value domain and ex- ecuted in a suitable monadic context that carries abstract program state. Unfortunately, correctly implementing these definitional interpreters re- mains a difficult task. Moreover, instantiating analyses requires config- uring many components. In this tool paper, we present the design of a framework called Monarch that provides reusable components to pro- grammers for implementing abstract definitional interpreters. Our design consists of the following components: abstract domains, a framework for expressing program semantics, and analysis instantiation techniques. Fi- nally, we present an implementation in Haskell and give example instan- tiations in Scheme and Python to show how these components are used.
@incollection{Vandenbogaerde2025Monarch, title = {Monarch: A Modular Framework for Abstract Definitional Interpreters in Haskell}, isbn = {9783032071064}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-032-07106-4_15}, doi = {10.1007/978-3-032-07106-4_15}, booktitle = {Static Analysis (SAS)}, publisher = {Springer Nature Switzerland}, author = {Vandenbogaerde, Bram and Verbelen, Sarah and Van Es, Noah and De Roover, Coen}, year = {2025}, month = oct, pages = {357–385} }
Performance Testing in Open-Source Web Projects: Adoption, Maintenance, and a Change Taxonomy

Sergio Di Meglio, Luigi Libero Lucio Starace, Valeria Pontillo, and 3 more authors

In 2025 IEEE International Conference on Software Maintenance and Evolution (ICSME), Sep 2025

Abs DOI Bib PDF

Performance testing is crucial to ensuring that web applications meet user expectations under varying workloads. Activities such as stress, load, and smoke testing are designed to simulate different kinds of simultaneous user interactions and assess system behavior. Despite its recognized importance in quality assurance of large-scale web-based systems, witnessed by numerous studies proposing solutions to support these activities, the real-world adoption and evolutionary dynamics of performance tests have received limited attention in the literature. To fill this gap, we analyzed 77 open-source web projects using APACHE JMETER and LOCUST. Our study investigates how performance tasks are performed (adoption time, load design, types of tasks), the characteristics of projects that adopt them, and their long-term maintenance. Our findings reveal that performance tests in open-source projects are simple, with a focus on single-user behaviors and minimal requests, and most tests have low concurrency. Load tests are the most common, followed by smoke and stress tests. Projects with performance tests tend to be larger and more actively maintained. However, tests are mostly long-lived but rarely updated, suggesting potential risks to their relevance and coverage over time. Finally, by creating a taxonomy of performance test changes, we observe recurring patterns of modifications, including workload adjustments, network request changes, and updates to system monitoring.
@inproceedings{DiMeglio2025Performance, title = {Performance Testing in Open-Source Web Projects: Adoption, Maintenance, and a Change Taxonomy}, url = {http://dx.doi.org/10.1109/ICSME64153.2025.00027}, doi = {10.1109/icsme64153.2025.00027}, booktitle = {2025 IEEE International Conference on Software Maintenance and Evolution (ICSME)}, publisher = {IEEE}, author = {Di Meglio, Sergio and Starace, Luigi Libero Lucio and Pontillo, Valeria and Opdebeeck, Ruben and De Roover, Coen and Di Martino, Sergio}, year = {2025}, month = sep, pages = {199–210} }
E2EGit: A Dataset of End-to-End Web Tests in Open Source Projects

Sergio Di Meglio, Luigi Libero Lucio Starace, Valeria Pontillo, and 3 more authors

In 2025 IEEE/ACM 22nd International Conference on Mining Software Repositories (MSR), Apr 2025

Distinguished Dataset Award Abs DOI Bib PDF

Distinguished Dataset Award, MSR 2025.

End-to-end (E2E) testing is a software validation approach that simulates realistic user scenarios throughout the entire workflow of an application. In the context of web applications, E2E testing involves two activities: Graphic User Interface (GUI) testing, which simulates user interactions with the web app’s GUI through web browsers, and performance testing, which evaluates system workload handling. Despite its recognized importance in delivering high-quality web applications, the availability of large-scale datasets featuring real-worldE2E web tests remains limited, hindering research in the field.To address this gap, we present E2EGit, a comprehensive dataset of non-trivial open-source web projects collected on GITHUB that adopt E2E testing. By analyzing over 5,000web repositories across popular programming languages (JAVA,JAVASCRIPT, TYPESCRIPT and PYTHON), we identified 472repositories implementing 43,670 automated Web GUI tests with popular browser automation frameworks (SELENIUM, PLAY-WRIGHT, CYPRESS, PUPPETEER), and 84 repositories that featured 271 automated performance tests implemented leveraging the most popular open-source tools (JMETER, LOCUST). Among these, 13 repositories implemented both types of testing for a total of 786 Web GUI tests and 61 performance tests.
@inproceedings{Meglio2025E, title = {E2EGit: A Dataset of End-to-End Web Tests in Open Source Projects}, url = {http://dx.doi.org/10.1109/MSR66628.2025.00121}, doi = {10.1109/msr66628.2025.00121}, booktitle = {2025 IEEE/ACM 22nd International Conference on Mining Software Repositories (MSR)}, publisher = {IEEE}, author = {Meglio, Sergio Di and Starace, Luigi Libero Lucio and Pontillo, Valeria and Opdebeeck, Ruben and Roover, Coen De and Martino, Sergio Di}, year = {2025}, month = apr, pages = {836–840} }
Analysing Software Supply Chains of Infrastructure as Code: Extraction of Ansible Plugin Dependencies

Ruben Opdebeeck, Bram Adams, and Coen De Roover

In 2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), Mar 2025

Abs DOI Bib PDF

The digital infrastructures supporting modern software have grown too complex to manage by hand. Therefore, Infrastructure as Code (IaC) has become a widely adopted practice to programmatically automate deploying such infrastructures. As infrastructure code may rely on third-party libraries and packages, understanding the software supply chains generated by these deployment dependencies is crucial to ensure reproducibility and security of software deployments. Nonetheless, deployment software supply chains remain an understudied topic. This paper aims to bridge this gap by first investigating which types of third-party software IaC may depend upon, then building an automated mechanism to identify such dependencies from infrastructure implementations. We focus our investigation on Ansible, one of the most popular IaC tools, and its plugins, which implement the interactions with the deployment platforms under configuration. From a manual analysis of 266 documented third-party requirements of Ansible plugins, we construct a taxonomy of 7 types of third-party software dependencies and their properties. We also found that a plugin’s dependencies are typically only described informally in the plugin’s documentation, which may be unstructured, incorrect, or incomplete, which encumbers the automatic generation of Software Bills of Materials (SBOMs) for deployment code. Therefore, we design an automated Software Composition Analysis (SCA) that extracts these dependencies from an Ansible plugin’s implementation, leveraging 5 dependency implementation patterns identified in our manual analysis. This approach achieves a recall of 61%– 77% and a precision of 74%–95%. Finally, we apply the SCA in a large-scale quantitative experiment on 11,241 plugins, and find that 38% have third-party dependencies. The taxonomy presented in this paper can serve as a reference to design deployment SBOMs for these plugins, whereas our SCA forms a first step towards automatically generating such SBOMs.
@inproceedings{Opdebeeck2025Analysing, title = {Analysing Software Supply Chains of Infrastructure as Code: Extraction of Ansible Plugin Dependencies}, url = {http://dx.doi.org/10.1109/SANER64311.2025.00025}, doi = {10.1109/saner64311.2025.00025}, booktitle = {2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)}, publisher = {IEEE}, author = {Opdebeeck, Ruben and Adams, Bram and De Roover, Coen}, year = {2025}, month = mar, pages = {181–192} }
Smelling Secrets: Leveraging Machine Learning and Language Models for Sensitive Parameter Detection in Ansible Security Analysis

Ruben Opdebeeck, Valeria Pontillo, Camilo Velázquez-Rodríguez, and 2 more authors

In 2025 IEEE International Conference on Source Code Analysis & Manipulation (SCAM), Sep 2025

Distinguished Research Paper Award Abs DOI Bib PDF

Distinguished Research Paper Award, SCAM 2025.

Infrastructure as Code is an emerging paradigm to automate the configuration of cloud infrastructures. Infrastructure code often processes secret information, such as passwords or private keys. Mishandling such secrets can lead to information disclosure vulnerabilities, yet existing efforts to detect them rely on pattern matching of parameter and variable names, causing false positives and negatives due to suboptimal string patterns. This paper aims to address these limitations by assessing the effectiveness of traditional Machine Learning (ML) and transformer-based Language Model (LM) classifiers to predict sensitive module parameters in Ansible, one of the most popular IaC tools. We collect a dataset of over 160,000 Ansible module parameters and their documentation, containing more than 16,000 parameters that expect secret data. Then, we train several ML algorithms and find that the Random Forest algorithm performs best, achieving 93.5% precision but limited recall (72.7%). In parallel, we evaluate multiple pretrained zero-shot language models, which achieve a recall of up to 90.4% at the expense of a lower precision of up to 88.5%. We subsequently fine-tune the language models, resulting in nearly perfect precision (99.8%) and recall (99.8%) on the ground truth dataset. We compare the best performing ML and LM classifiers to two baselines that use string patterns. We find that the ML classifier achieves a performance comparable to the two baselines, while the fine-tuned LM outperforms all approaches. A qualitative comparison reveals that the approaches are complementary to the baselines, motivating future work to use prediction models to reduce false positives in reports generated by inexpensive baselines. However, we also find that the fine-tuned LM misses several secrets caused by noise in the dataset, highlighting the importance of fine-tuning on a high-quality ground truth.
@inproceedings{Opdebeeck2025Smelling, title = {Smelling Secrets: Leveraging Machine Learning and Language Models for Sensitive Parameter Detection in Ansible Security Analysis}, url = {http://dx.doi.org/10.1109/SCAM67354.2025.00014}, doi = {10.1109/scam67354.2025.00014}, booktitle = {2025 IEEE International Conference on Source Code Analysis &amp; Manipulation (SCAM)}, publisher = {IEEE}, author = {Opdebeeck, Ruben and Pontillo, Valeria and Velázquez-Rodríguez, Camilo and De Meuter, Wolfgang and De Roover, Coen}, year = {2025}, month = sep, pages = {66–77} }
Onweer: Automated Resilience Testing Through Fuzzing

Gilles Coremans and Coen De Roover

In 2025 IEEE International Conference on Software Maintenance and Evolution (ICSME), Sep 2025

Abs DOI Bib PDF

Micro-service architectures remain a popular choice for cloud applications. However, micro-service applications are subject to faults such as dropped requests between services which are difficult to catch during development in testing environments. Automated testing tools have been proposed to test the resilience of micro-service applications against faults in testing, but these require manually specifying execution scenarios. In this paper, we propose an approach to resilience testing which integrates fault injection into the fuzzing process. In this way, system executions and faults can be simultaneously explored, allowing fully automated resilience testing. We describe our approach as well as a prototype implementation called \Onweer{}, and evaluate its performance on a standard micro-service benchmark application.
@inproceedings{Coremans2025Onweer, title = {Onweer: Automated Resilience Testing Through Fuzzing}, url = {http://dx.doi.org/10.1109/ICSME64153.2025.00031}, doi = {10.1109/icsme64153.2025.00031}, booktitle = {2025 IEEE International Conference on Software Maintenance and Evolution (ICSME)}, publisher = {IEEE}, author = {Coremans, Gilles and De Roover, Coen}, year = {2025}, month = sep, pages = {248–259} }

2024

Blame-Correct Support for Receiver Properties in Recursively-Structured Actor Contracts

Bram Vandenbogaerde, Quentin Stiévenart, and Coen De Roover

Proceedings of the ACM on Programming Languages (ICFP), Aug 2024

Abs DOI Bib PDF

Actor languages model concurrency as processes that communicate through asynchronous message sends. Unfortunately, as the complexity of these systems increases, it becomes more difficult to compose and integrate their components. This is because of assumptions made by components about their communication partners which may not be upheld when they remain implicit. In this paper, we bring design-by-contract programming to actor programs through a contract system that enables expressing constraints on receiver-related properties. Expressing properties about the expected receiver of a message, and about this receiver’s communication behavior, requires two novel types of contracts. Through their recursive structure, these contracts can govern entire communication chains. We implement the contract system for an actor extension of Scheme, describe it formally, and show how to assign blame in case of a contract violation. Finally, we prove our contract system and its blame assignment correct by formulating and proving a blame correctness theorem.
@article{Vandenbogaerde2024Blame, title = {Blame-Correct Support for Receiver Properties in Recursively-Structured Actor Contracts}, volume = {8}, issn = {2475-1421}, url = {http://dx.doi.org/10.1145/3674643}, doi = {10.1145/3674643}, number = {ICFP}, journal = {Proceedings of the ACM on Programming Languages (ICFP)}, publisher = {Association for Computing Machinery (ACM)}, author = {Vandenbogaerde, Bram and Stiévenart, Quentin and De Roover, Coen}, year = {2024}, month = aug, pages = {515–543} }
Property-based Testing within ML Projects: an Empirical Study

Cindy Wauters and Coen De Roover

In 2024 IEEE International Conference on Software Maintenance and Evolution (ICSME), Oct 2024

Abs DOI Bib PDF

In property-based testing (PBT), developers specify properties that they expect the system under test to hold. The PBT tool generates random inputs for the system and tests for each of these inputs whether the given property holds. An advantage of this approach over testing a set of manually defined example inputs is that it enables a higher code coverage. Machine learning (ML) projects, however, often have to process large amounts of diverse data, both for training a model and afterwards, when the trained model is deployed. Generating a sufficient amount of diverse data for the property-based tests is therefore challenging. In this paper, we present the results of a preliminary study in which we examined a dataset of 58 open-source ML projects that have dependencies on the popular PBT library Hypothesis, to identify issues faced by developers writing property-based tests. For a subset of 28 open-source ML projects, we study the property-based tests in detail and report on the part of the ML project that is being tested as well as on the adopted data generation strategies. This way, we aim to identify issues in porting current PBT techniques to ML projects so that they can be addressed in the future.
@inproceedings{Wauters2024Property, title = {Property-based Testing within ML Projects: an Empirical Study}, url = {http://dx.doi.org/10.1109/ICSME58944.2024.00067}, doi = {10.1109/icsme58944.2024.00067}, booktitle = {2024 IEEE International Conference on Software Maintenance and Evolution (ICSME)}, publisher = {IEEE}, author = {Wauters, Cindy and De Roover, Coen}, year = {2024}, month = oct, pages = {648–653} }
Threats to Instrument Validity Within “in Silico” Research: Software Engineering to the Rescue

Serge Demeyer, Coen De Roover, Mutlu Beyazit, and 1 more author

In Leveraging Applications of Formal Methods, Verification and Validation. Software Engineering Methodologies (ISOLA), Oct 2024

Abs DOI Bib PDF

“In Silico” research drives the world around us, as illustrated by the way our society handles climate change, controls the COVID-19 pandemic and governs economic growth. Unfortunately, the code embedded in the underlying data processing is mostly written by scientists lacking formal training in software engineering. The resulting code is vulnerable, suffering from what is known as threats to instrument validity.This position paper aims to understand and remedy threats to instrument validity in current “in silico” research. To achieve this goal, we specify a research agenda listing how recent software engineering achievements may improve “in silico” research (SE4Silico) and, conversely, how software engineering may strengthen its applicability (Silico4SE).
@incollection{Demeyer2024Threats, title = {Threats to Instrument Validity Within “in Silico” Research: Software Engineering to the Rescue}, isbn = {9783031753879}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-031-75387-9_6}, doi = {10.1007/978-3-031-75387-9_6}, booktitle = {Leveraging Applications of Formal Methods, Verification and Validation. Software Engineering Methodologies (ISOLA)}, publisher = {Springer Nature Switzerland}, author = {Demeyer, Serge and Roover, Coen De and Beyazit, Mutlu and Härtel, Johannes}, year = {2024}, month = oct, pages = {82–96} }

2023

Formalizing, Verifying and Applying ISA Security Guarantees as Universal Contracts

Sander Huyghebaert, Steven Keuchel, Coen De Roover, and 1 more author

In Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security (CCS), Nov 2023

Abs DOI Bib PDF

Progress has recently been made on specifying instruction set ar- chitectures (ISAs) in executable formalisms rather than through prose. However, to date, those formal specifications are limited to the functional aspects of the ISA and do not cover its security guarantees. We present a novel, general method for formally speci- fying an ISA’s security guarantees to (1) balance the needs of ISA implementations (hardware) and clients (software), (2) can be semi- automatically verified to hold for the ISA operational semantics, producing a high-assurance mechanically-verifiable proof, and (3) support informal and formal reasoning about security-critical soft- ware in the presence of adversarial code. Our method leverages universal contracts: software contracts that express bounds on the authority of arbitrary untrusted code. Universal contracts can be kept agnostic of software abstractions, and strike the right balance between requiring sufficient detail for reasoning about software and preserving implementation freedom of ISA designers and CPU implementers. We semi-automatically verify universal contracts against Sail implementations of ISA semantics using our Kata- maran tool; a semi-automatic separation logic verifier for Sail which produces machine-checked proofs for successfully verified contracts. We demonstrate the generality of our method by ap- plying it to two ISAs that offer very different security primitives: (1) MinimalCaps: a custom-built capability machine ISA and (2) a (somewhat simplified) version of RISC-V with PMP. We verify a femtokernel using the security guarantee we have formalized for RISC-V with PMP.
@inproceedings{Huyghebaert2023Formalizing, series = {CCS ’23}, title = {Formalizing, Verifying and Applying ISA Security Guarantees as Universal Contracts}, url = {http://dx.doi.org/10.1145/3576915.3616602}, doi = {10.1145/3576915.3616602}, booktitle = {Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security (CCS)}, publisher = {ACM}, author = {Huyghebaert, Sander and Keuchel, Steven and De Roover, Coen and Devriese, Dominique}, year = {2023}, month = nov, pages = {2083–2097}, collection = {CCS ’23} }
The Docker Hub Image Inheritance Network: Construction and Empirical Insights

Ruben Opdebeeck, Jonas Lesy, Ahmed Zerouali, and 1 more author

In 2023 IEEE 23rd International Working Conference on Source Code Analysis and Manipulation (SCAM), Oct 2023

Abs DOI Bib PDF

Docker is a popular technology to containerise applications together with their dependencies into reproducible environments. In Docker, container images can depend on others through inheritance. Such inheritance can propagate bad practices and security vulnerabilities from a parent image to its children. Unfortunately, Docker Hub, the most popular online registry of images, lacks transparency about such inheritance. This obscures the software supply chain, possibly leaving image users unaware of quality or security issues caused by parent images. Nonetheless, we found inheritance on Docker Hub to be an understudied topic in academia to date. Therefore, the goal of this paper is to empirically investigate the practice of image inheritance on Docker Hub. To this end, we collect a dataset of 636,625 unique images belonging to popular Docker repositories and identify inheritance by comparing the images’ layers. We leverage the constructed inheritance network to empirically investigate three aspects, namely the structure of the inheritance network, how child images differ from their parents, and outdatedness of parent images. Our results show that most popular community Docker Hub images directly inherit from official images rather than other community ones. We also observe that community child images are often much larger than their parent, in comparison to official child images. This may indicate the existence of gaps between the features provided by official images and those required by consumers, suggesting the need for more ready-made parent images. Finally, we find that around half of the child images use an outdated parent image at the time the child is built, although time lag is usually less than a month. However, time lag becomes much larger when we compare against the latest version of the parent image available at the analysis date, with up to 70% of child images using an outdated parent image and a median of over 5 months of time lag. This indicates that users should pay attention to the lineage of the images they consume, and motivates future work on alleviating technical lag in Docker images.
@inproceedings{Opdebeeck2023Docker, title = {The Docker Hub Image Inheritance Network: Construction and Empirical Insights}, url = {http://dx.doi.org/10.1109/SCAM59687.2023.00029}, doi = {10.1109/scam59687.2023.00029}, booktitle = {2023 IEEE 23rd International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Opdebeeck, Ruben and Lesy, Jonas and Zerouali, Ahmed and De Roover, Coen}, year = {2023}, month = oct, pages = {198–208} }
Control and Data Flow in Security Smell Detection for Infrastructure as Code: Is It Worth the Effort?

Ruben Opdebeeck, Ahmed Zerouali, and Coen De Roover

In 2023 IEEE/ACM 20th International Conference on Mining Software Repositories (MSR), May 2023

Abs DOI Bib PDF

Infrastructure as Code is the practice of developing and maintaining computing infrastructure through executable source code. Unfortunately, IaC has also brought about new cyber attack vectors. Prior work has therefore proposed static analyses that detect security smells in Infrastructure as Code files. However, they have so far remained at a shallow level, disregarding the control and data flow of the scripts under analysis, and may lack awareness of specific syntactic constructs. These limitations inhibit the quality of their results. To address these limitations, in this paper, we present GASEL, a novel security smell detector for the Ansible IaC language. It uses graph queries on program dependence graphs to detect 7 security smells. Our evaluation on an oracle of 243 real-world security smells and comparison against two state-of-the-art security smell detectors shows that awareness of syntax, control flow, and data flow enables our approach to substantially improve both precision and recall. We further question whether the additional effort required to develop and run such an approach is justified in practice. To this end, we investigate the prevalence of indirection through control and data flow in security smells across more than 15 000 Ansible scripts. We find that over 55% of security smells contain data-flow indirection, and over 32% require a whole-project analysis to detect. These findings motivate the need for deeper static analysis tools to detect security vulnerabilities in IaC.
@inproceedings{Opdebeeck2023Control, title = {Control and Data Flow in Security Smell Detection for Infrastructure as Code: Is It Worth the Effort?}, url = {http://dx.doi.org/10.1109/MSR59073.2023.00079}, doi = {10.1109/msr59073.2023.00079}, booktitle = {2023 IEEE/ACM 20th International Conference on Mining Software Repositories (MSR)}, publisher = {IEEE}, author = {Opdebeeck, Ruben and Zerouali, Ahmed and De Roover, Coen}, year = {2023}, month = may, pages = {534–545} }
Dynamic Slicing of WebAssembly Binaries

Quentin Stiévenart, David Binkley, and Coen De Roover

In 2023 IEEE International Conference on Software Maintenance and Evolution (ICSME), Oct 2023

Abs DOI Bib PDF

The recently introduced WebAssembly standard aims to form a portable compilation target, enabling the cross- platform distribution of programs written in a variety of lan- guages. In this paper, we propose and investigate the first dynamic slicing approaches for WebAssembly. Given a program and a location in that program, a program slice is a reduced version of the program that preserves the behavior at the given location. Slicing has numerous applications in software maintenance and evolution, including reverse engineering, code comprehension, and quality assurance. Our dynamic approaches are built on Observational-Based Slicing (ORBS). We explore the design space for instantiating ORBS for WebAssembly: for example, it can be applied to the whole program or to only the function containing the slicing criterion, and it can be applied before compilation to WebAssembly or afterwards. We evaluate the slices produced quantitatively and qualitatively, and compare them to those obtained by a state-of-the-art static slicer for WebAssembly. Our evaluation reveals that dynamic slicing at the level of a function from a WebAssembly binary finds a sweet spot in terms of slice time and slice size.
@inproceedings{Stivenart2023Dynamic, title = {Dynamic Slicing of WebAssembly Binaries}, url = {http://dx.doi.org/10.1109/ICSME58846.2023.00020}, doi = {10.1109/icsme58846.2023.00020}, booktitle = {2023 IEEE International Conference on Software Maintenance and Evolution (ICSME)}, publisher = {IEEE}, author = {Stiévenart, Quentin and Binkley, David and De Roover, Coen}, year = {2023}, month = oct, pages = {84–96} }
Cross-Level Debugging for Static Analysers

Mats Van Molle, Bram Vandenbogaerde, and Coen De Roover

In Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering (SLE), Oct 2023

Abs DOI Bib PDF

Static analyses provide the foundation for several tools that help developers find problems before executing the program under analysis. Common applications include warning about unused code, deprecated API calls, or about potential security vulnerabilities within an IDE. A static analysis distinguishes itself from a dynamic analysis in that it is supposed to termi- nate even if the program under analysis does not. In many cases it is also desired for the analysis to be sound, meaning that its answers account for all possible program behavior. Unfortunately, analysis developers may make mistakes that violate these properties resulting in hard-to-find bugs in the analysis code itself. Finding these bugs can be a difficult task, especially since analysis developers have to reason about two separate code-bases: the analyzed code and the analysis implementation. The former is usually where the bug man- ifests itself, while the latter contains the faulty implemen- tation. A recent survey has found that analysis developers prefer to reason about the analyzed program, indicating that debugging would be easier if debugging features such as (conditional) breakpoints and stepping were also available in the analyzed program. In this paper, we therefore propose cross-level debugging for static analysis. This novel technique moves debugging features such as stepping and breakpoints to the base-layer (i.e., analyzed program), while still making interactions with the meta-layer (i.e., analysis implementa- tion) possible. To this end, we introduce novel conditional breakpoints that express conditions, which we call meta- predicates, about the current analysis’ state. We integrated this debugging technique in a framework for implement- ing modular abstract interpretation-based static analyses called MAF. Through a detailed case study on 4 real-world bugs taken from the repository of MAF, we demonstrate how cross-level debugging helps analysis developers in locating and solving bugs.
@inproceedings{VanMolle2023Cross, series = {SLE ’23}, title = {Cross-Level Debugging for Static Analysers}, url = {http://dx.doi.org/10.1145/3623476.3623512}, doi = {10.1145/3623476.3623512}, booktitle = {Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering (SLE)}, publisher = {ACM}, author = {Van Molle, Mats and Vandenbogaerde, Bram and De Roover, Coen}, year = {2023}, month = oct, pages = {138–148}, collection = {SLE ’23} }
MODINF: Exploiting Reified Computational Dependencies for Information Flow Analysis

Jens Plas, Jens Nicolay, Wolfgang De Meuter, and 1 more author

In Proceedings of the 18th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE), 2023

Abs DOI Bib PDF

Information Flow Control is important for securing applications, primarily to preserve the confidentiality and integrity of applications and the data they process. Statically determining the flows of information for security purposes helps to secure applications early in the development pipeline. However, a sound and precise static analysis is difficult to scale. Modular static analysis is a technique for improving the scalability of static analysis. In this paper, we present an approach for constructing a modular static analysis for performing Information Flow Control for higher-order, imperative programs. A modular analysis requires information about data dependencies between modules. These dependencies arise as a result of information flows between modules, and therefore we piggy-back an Information Flow Control analysis on top of an existing modular analysis. Additionally, the resulting modular Information Flow Control analysis retains the benefits of its modular character. We validate our approach by performing an Information Flow Control analysis on 9 synthetic benchmark programs that contain both explicit and implicit information flows.
@inproceedings{VanderPlas2023MODINF, title = {MODINF: Exploiting Reified Computational Dependencies for Information Flow Analysis}, url = {http://dx.doi.org/10.5220/0011849900003464}, doi = {10.5220/0011849900003464}, booktitle = {Proceedings of the 18th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE)}, publisher = {SCITEPRESS - Science and Technology Publications}, author = {Van der Plas, Jens and Nicolay, Jens and De Meuter, Wolfgang and De Roover, Coen}, year = {2023}, pages = {420–427} }
Result Invalidation for Incremental Modular Analyses

Jens Plas, Quentin Stiévenart, and Coen De Roover

In Verification, Model Checking, and Abstract Interpretation (VMCAI), 2023

Abs DOI Bib PDF

To reduce the running time of static analysis tools upon pro- gram changes, incremental static analyses reuse and update pre-existing results. Such analyses must eﬃciently detect and remove outdated re- sults. We introduce three novel, complementary result invalidation strate- gies for incremental modular analyses. The core idea of our work is to alternate invalidation with computation. We apply our strategies to a re- cent, state-of-the-art incremental modular analysis that suﬀers from im- precision, and evaluate them on soundness, precision, and performance. Our strategies lead to precision improvements compared to an incremen- tal analysis without invalidation, though the precision of a full reanal- ysis is not yet matched. On most benchmarks, our incremental analy- sis performs well. However, on some benchmarks our analysis performs poorly as the changes drastically change program behaviour, for which the changes are diﬃcult for an incremental analysis to handle.
@incollection{VanderPlas2023Result, title = {Result Invalidation for Incremental Modular Analyses}, isbn = {9783031249501}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-031-24950-1_14}, doi = {10.1007/978-3-031-24950-1_14}, booktitle = {Verification, Model Checking, and Abstract Interpretation (VMCAI)}, publisher = {Springer Nature Switzerland}, author = {Van der Plas, Jens and Stiévenart, Quentin and De Roover, Coen}, year = {2023}, pages = {296–319} }
Change Pattern Detection for Optimising Incremental Static Analysis

Cindy Wauters, Jens Van der Plas, Quentin Stiévenart, and 1 more author

In 2023 IEEE 23rd International Working Conference on Source Code Analysis and Manipulation (SCAM), Oct 2023

Abs DOI Bib PDF

Static analyses can be used by developers to compute properties of a program, enabling e.g., bug detection and program verification. However, reanalysing a program from scratch upon every change is time-consuming, especially in settings where code changes often, such as within IDEs. To avoid such full reanalyses, incremental analyses instead reuse parts of the previous analysis result, and reanalyse the changed code as necessary. While incrementality improves the analysis time, we introduce a complementary approach that further reduces the analysis time. A traditional incremental analysis updates previous analysis results without domain-specific knowledge. However, the effect of particular source code changes on analysis results can be predicted. Performing a traditional incremental analysis of the changed code might therefore be unnecessary. Instead, we propose to detect code change patterns of which the effect on analysis results can be predicted and to update these results accordingly, saving potentially expensive computations. In this paper, we explore the idea of adapting the analysis results for behaviour-preserving change patterns. In particular, we consider consistent renamings, inverted conditionals, and moved function definitions within Scheme programs. We implemented our approach and evaluated it on 30 programs. We show decreases in incremental analysis time between 3% and 99% on 25 programs that contain at least one behaviour-preserving change pattern.
@inproceedings{Wauters2023Change, title = {Change Pattern Detection for Optimising Incremental Static Analysis}, url = {http://dx.doi.org/10.1109/SCAM59687.2023.00016}, doi = {10.1109/scam59687.2023.00016}, booktitle = {2023 IEEE 23rd International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Wauters, Cindy and Plas, Jens Van der and Stiévenart, Quentin and Roover, Coen De}, year = {2023}, month = oct, pages = {49–60} }
Helm Charts for Kubernetes Applications: Evolution, Outdatedness and Security Risks

Ahmed Zerouali, Ruben Opdebeeck, and Coen De Roover

In 2023 IEEE/ACM 20th International Conference on Mining Software Repositories (MSR), May 2023

Abs DOI Bib PDF

Using Kubernetes for the deployment, management and scaling of containerized applications has become a common practice. To facilitate the installation and management of these applications, practitioners can use the Helm package manager to assemble their configuration files into charts. The latter are reusable packages of pre-configured Kubernetes resources that can be deployed as a unit. In this paper, we aim to support chart developers and users by carrying out a comprehensive study on publicly available charts. For 9,482 charts that are distributed via the Artifact Hub repository, we mine and collect the list of their metadata, versions, dependencies, maintainers and container images. Then, we carry out an empirical analysis to assess the state and evolution of charts, as well as the outdatedness and security risks of their images. We found that the ecosystem forming around Helm charts is growing fast. However, most of the charts are not official with no popularity and no license. We also observed that charts tend to release multiple versions, but around half of them are still in the initial development phase. When looking at the container images used in charts, we found that around half of them are outdated and 88.1% of them are exposed to vulnerabilities, jeopardizing 93.7% of the charts.
@inproceedings{Zerouali2023Helm, title = {Helm Charts for Kubernetes Applications: Evolution, Outdatedness and Security Risks}, url = {http://dx.doi.org/10.1109/MSR59073.2023.00078}, doi = {10.1109/msr59073.2023.00078}, booktitle = {2023 IEEE/ACM 20th International Conference on Mining Software Repositories (MSR)}, publisher = {IEEE}, author = {Zerouali, Ahmed and Opdebeeck, Ruben and De Roover, Coen}, year = {2023}, month = may, pages = {523–533} }
Symbolic Execution to Detect Semantic Merge Conflicts

Ward Muylaert, Johannes Härtel, and Coen De Roover

In 2023 IEEE 23rd International Working Conference on Source Code Analysis and Manipulation (SCAM), Oct 2023

Abs DOI Bib PDF

Collaborative software development depends on managing multiple versions of a program which requires mechanisms to merge program versions to eventually deploy a single executable. Merging program versions can be challenging as conflicts can arise. The most challenging form is a semantic conflict, which introduces unintended behaviour in the resulting executable while merging. In this paper, we develop an approach that detects such semantic merge conflicts by symbolic execution. We define the program semantics as path conditions, produced by a symbolic executor, and check whether the conditions satisfy established rules that reflect a merge conflict. Our usage of symbolic execution to check these rules is novel. We evaluate the correctness of our approach through mutation testing, and evaluate it empirically by applying the approach to real-world merges sampled from GitHub. We also discuss what challenges arise in the empirical evaluation, including the problems i) that semantic merge conflicts are rare in the wild, ii) and, even in retrospection, hard to find using standard search mechanisms. Our evaluation shows that in specific cases, our approach using symbolic execution is a promising extension to existing mechanisms to merge conflict detection.
@inproceedings{Muylaert2023Symbolic, title = {Symbolic Execution to Detect Semantic Merge Conflicts}, url = {http://dx.doi.org/10.1109/SCAM59687.2023.00028}, doi = {10.1109/scam59687.2023.00028}, booktitle = {2023 IEEE 23rd International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Muylaert, Ward and Härtel, Johannes and De Roover, Coen}, year = {2023}, month = oct, pages = {186–197} }

2022

Static stack-preserving intra-procedural slicing of webassembly binaries

Quentin Stiévenart, David W. Binkley, and Coen De Roover

In Proceedings of the 44th International Conference on Software Engineering (ICSE), May 2022

Best Artifact Award Abs DOI Bib PDF

Best Artifact Award, ICSE 2022.

The recently introduced WebAssembly standard aims to be a portable compilation target, enabling the cross-platform distribution of programs written in a variety of languages. We propose an approach to slice WebAssembly programs in order to enable applications in reverse engineering, code comprehension, and security among others. Given a program and a location in that program, program slicing produces a minimal version of the program that preserves the behavior at the given location. Specifically, our approach is a static, intra-procedural, backwards slicing approach that takes into account WebAssembly-specific dependences to identify the instructions of the slice. To do so it must correctly overcome the considerable challenges of performing dependence analysis at the binary level. Furthermore, for the slice to be executable, the approach needs to ensure that the stack behavior of its output complies with WebAssembly’s validation requirements. We implemented and evaluated our approach on a suite of 8,386 real-world WebAssembly binaries, finding that the average size of the 97,728,325 slices computed is 46% of the original code, an improvement over the 60% attained by related work on slicing ARM binaries. To gain a more qualitative understanding of the slices produced by our approach, we compared them to 1,956 source-level slices of benchmark C programs. This inspection helps to illustrate the slicer’s strengths and to uncover potential future improvements.
@inproceedings{Stivenart2022Static, series = {ICSE ’22}, title = {Static stack-preserving intra-procedural slicing of webassembly binaries}, url = {http://dx.doi.org/10.1145/3510003.3510070}, doi = {10.1145/3510003.3510070}, booktitle = {Proceedings of the 44th International Conference on Software Engineering (ICSE)}, publisher = {ACM}, author = {Stiévenart, Quentin and Binkley, David W. and De Roover, Coen}, year = {2022}, month = may, pages = {2031–2042}, collection = {ICSE ’22} }
Variant Forks - Motivations and Impediments

John Businge, Ahmed Zerouali, Alexandre Decan, and 3 more authors

In 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), Mar 2022

Abs DOI Bib PDF

Social coding platforms centred around git provide explicit facilities to share code between projects: forks, pull requests, cherry-picking to name but a few. Variant forks are an interesting phenomenon in that respect, as they permit for different projects to peacefully co-exist, yet explicitly acknowledge the common ancestry. Several researchers analysed forking practices on open source platforms and observed that variant forks get created frequently. However, little is known on the motivations for launching such a variant fork. Is it mainly technical (e.g., diverging features), governance (e.g., diverging interests), legal (e.g., diverging licences), or do other factors come into play? We report the results of an exploratory qualitative analysis on the motivations behind creating and maintaining variant forks. We surveyed 105 maintainers of different active open source variant projects hosted on GitHub. Our study extends previous findings, identifying a number of fine-grained common motivations for launching a variant fork and listing concrete impediments for maintaining the co-existing projects.
@inproceedings{Businge2022Variant, title = {Variant Forks - Motivations and Impediments}, url = {http://dx.doi.org/10.1109/SANER53432.2022.00105}, doi = {10.1109/saner53432.2022.00105}, booktitle = {2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)}, publisher = {IEEE}, author = {Businge, John and Zerouali, Ahmed and Decan, Alexandre and Mens, Tom and Demeyer, Serge and De Roover, Coen}, year = {2022}, month = mar, pages = {867–877} }
RacketLogger: Logging and Visualising Changes in DrRacket

Turgut Reis Kursun, Jens Plas, Quentin Stiévenart, and 1 more author

Proceedings of the 15th European Lisp Symposium (ELS), 2022

Abs DOI Bib PDF

Developers frequently make code changes while programming, such as deleting a line of code and renaming or introducing a variable. These changes can be detected and logged, for example by the IDE used by the developer. Logging changes is possible at two levels: at the textual level or at the level of the abstract syntax tree (AST) of the program. The logged changes, in both forms, are useful because they can be used to build new software engineering tools, such as static code analysers. Plugins that log changes have already been developed for some IDEs. However, so far, no change-logging plugin has been developed for the DrRacket IDE, which supports the development of programs written in Scheme-like languages such as R5RS Scheme and Racket. To fill this gap, we have developed RacketLogger, a change-logging plugin for DrRacket. RacketLogger logs changes both at the textual level and at the AST level. To determine changes at the level of the AST, we have adapted Negara et al.’s algorithm to support Scheme syntax. We have evaluated our plugin by creating a visualisation for the logged changes to measure how well RacketLogger can be used as a building block, and conducted a small-scale user study to measure its usability.
@article{Kursun2022RacketLogger, journal = {Proceedings of the 15th European Lisp Symposium (ELS)}, doi = {10.5281/ZENODO.6326894}, url = {https://zenodo.org/record/6326894}, author = {Kursun, Turgut Reis and Van der Plas, Jens and Stiévenart, Quentin and De Roover, Coen}, keywords = {Racket, change logging, IDEs}, language = {en}, title = {RacketLogger: Logging and Visualising Changes in DrRacket}, publisher = {Zenodo}, year = {2022}, copyright = {Creative Commons Attribution 4.0 International} }
Prevalence and Evolution of License Violations in npm and RubyGems Dependency Networks

Ilyas Saïd Makari, Ahmed Zerouali, and Coen De Roover

In Reuse and Software Quality (ICSR), 2022

Abs DOI Bib PDF

It can be challenging to manage an open source package from a licensing perspective. License violations can be introduced by both direct and indirect package dependencies, which evolve independently. In this paper, we propose a license compatibility matrix as the foundation for a tool that can help maintainers assess the compliance of their package with the licenses of its dependencies. Using this tool, we empirically study the evolution, popularity, and compliance with dependency licenses in the npm and RubyGems software package ecosystems. The size of the corresponding dependency networks renders verifying license compliance for indirect dependencies computationally expensive. We found that 7.3% of npm packages and 13.9% of RubyGems have direct or indirect dependencies with incompatible licenses. We also found that GPL dependencies are the major cause for incompatibilities. Our results provide a good understanding of the state of license incompatibilities in software package ecosystems, and suggest that individual ecosystems can differ significantly in this regard.
@incollection{Makari2022Prevalence, title = {Prevalence and Evolution of License Violations in npm and RubyGems Dependency Networks}, isbn = {9783031081293}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-031-08129-3_6}, doi = {10.1007/978-3-031-08129-3_6}, booktitle = {Reuse and Software Quality (ICSR)}, publisher = {Springer International Publishing}, author = {Makari, Ilyas Saïd and Zerouali, Ahmed and De Roover, Coen}, year = {2022}, pages = {85–100} }
Smelly variables in ansible infrastructure code: detection, prevalence, and lifetime

Ruben Opdebeeck, Ahmed Zerouali, and Coen De Roover

In Proceedings of the 19th International Conference on Mining Software Repositories (MSR), May 2022

Abs DOI Bib PDF

Infrastructure as Code is the practice of automating the provisioning, configuration, and orchestration of network nodes using code in which variable values such as configuration parameters, node hostnames, etc. play a central role. Mistakes in these values are an important cause of infrastructure defects and corresponding outages. Ansible, a popular IaC language, nonetheless features semantics which can cause confusion about the value of variables. In this paper, we identify six novel code smells related to Ansible’s intricate variable precedence rules and lazy-evaluated template expressions. Their detection requires an accurate representation of control and data flow, for which we transpose the program dependence graph to Ansible. We use the resulting detector to empirically investigate the prevalence of these variable smells in 21,931 open-source Ansible roles, uncovering 31,334 unique smell instances across 4,260 roles. We observe an upward trend in the number of variable smells over time, that it may take a long time before they are fixed, and that code changes more often introduce new smells than fix existing ones. Our results are a call to arms for more in-depth quality checkers for IaC code, and highlight the importance of transcending syntax in IaC research.
@inproceedings{Opdebeeck2022Smelly, series = {MSR ’22}, title = {Smelly variables in ansible infrastructure code: detection, prevalence, and lifetime}, url = {http://dx.doi.org/10.1145/3524842.3527964}, doi = {10.1145/3524842.3527964}, booktitle = {Proceedings of the 19th International Conference on Mining Software Repositories (MSR)}, publisher = {ACM}, author = {Opdebeeck, Ruben and Zerouali, Ahmed and De Roover, Coen}, year = {2022}, month = may, pages = {61–72}, collection = {MSR ’22} }
Mining for Framework Instantiation Pattern Interplays

Yunior Pacheco, Ahmed Zerouali, and Coen De Roover

In 2022 IEEE 22nd International Working Conference on Source Code Analysis and Manipulation (SCAM), Oct 2022

Abs DOI Bib PDF

Software frameworks define generic application blueprints which can be instantiated into an application through application-specific instantiation actions such as overriding a method or providing an object that implements an interface. In case the framework’s documentation falls short, developers may use other instantiations of the same framework as a guide to the required instantiation actions. In this paper, we propose an automated approach to mining framework instantiation patterns from existing open-source instantiations. The approach leverages a graph-based representation to capture the common ways of implementing instantiation actions as well as their interplays, so called instantiation interplays. As a case study, we mined for patterns in a set of 2,028 Java projects that instantiate four of the most popular Java frameworks. We also classify the extracted interplays according to the different contexts in which they occur. We found that our approach discovers relevant practices and interplays that are not covered by previous approaches. Our results will allow developers to have a better understanding of the frameworks they instantiate.
@inproceedings{Pacheco2022Mining, title = {Mining for Framework Instantiation Pattern Interplays}, url = {http://dx.doi.org/10.1109/SCAM55253.2022.00019}, doi = {10.1109/scam55253.2022.00019}, booktitle = {2022 IEEE 22nd International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Pacheco, Yunior and Zerouali, Ahmed and De Roover, Coen}, year = {2022}, month = oct, pages = {121–131} }
PaReco: patched clones and missed patches among the divergent variants of a software family

Poedjadevie Kadjel Ramkisoen, John Businge, Brent Bladel, and 4 more authors

In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE), Nov 2022

Abs DOI Bib PDF

Re-using whole repositories as a starting point for new projects is often done by maintaining a variant fork parallel to the original. However, the common artifacts between both projects are not always kept up to date. As a result, patches are not optimally integrated across the two projects, which may lead to sub-optimal maintenance between the variant and the original project. For example, a bug existing in both projects can be patched in one but not the other (we see this as a missed opportunity). Furthermore, different developers can manually patch the bug (we see this as effort duplication). This paper presents a tool (named PaReco) that relies on clone detection to mine cases of missed opportunity and effort duplication from a pool of updates. We analyzed 364 (source to target) variant pairs with 8,323 patches resulting in a curated dataset containing 1,116 cases of effort duplication and 1,008 cases of missed opportunities. As a result, we achieve a precision of 91%, recall of 80%, accuracy of 88%, and F1-score of 85%. Furthermore, we investigated the time interval between patches and found out that, on average, missed patches in the target variants have been introduced in the source variants 52 weeks earlier. Consequently, PaReco can be used to manage variability in “time” by automatically identifying interesting patches in later project releases to be backported to supported earlier releases.
@inproceedings{Ramkisoen2022PaReco, series = {ESEC/FSE ’22}, title = {PaReco: patched clones and missed patches among the divergent variants of a software family}, url = {http://dx.doi.org/10.1145/3540250.3549112}, doi = {10.1145/3540250.3549112}, booktitle = {Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE)}, publisher = {ACM}, author = {Ramkisoen, Poedjadevie Kadjel and Businge, John and van Bladel, Brent and Decan, Alexandre and Demeyer, Serge and De Roover, Coen and Khomh, Foutse}, year = {2022}, month = nov, pages = {646–658}, collection = {ESEC/FSE ’22} }
Security risks of porting C programs to webassembly

Quentin Stiévenart, Coen De Roover, and Mohammad Ghafari

In Proceedings of the 37th ACM/SIGAPP Symposium on Applied Computing (SAC), Apr 2022

Abs DOI Bib PDF

WebAssembly is a compilation target for cross-platform applications that is increasingly being used. In this paper, we investigate whether one can transparently cross-compile C programs to WebAssembly, and if not, what impact porting can have on their security. We compile 17 802 programs that exhibit common vulnerabilities to 64-bit x86 and to WebAssembly binaries, and we observe that the execution of 4 911 binaries produces different results across these platforms. Through manual inspection, we identify three classes of root causes for such differences: the use of a different standard library implementation, the lack of security measures in WebAssembly, and the different semantics of the execution environments. We describe our observations and discuss the ones that are critical from a security point of view and need most attention from developers. We conclude that compiling an existing C program to WebAssembly for cross-platform distribution may require source code adaptations; otherwise, the security of the WebAssembly application may be at risk.
@inproceedings{Stivenart2022Security, series = {SAC ’22}, title = {Security risks of porting C programs to webassembly}, url = {http://dx.doi.org/10.1145/3477314.3507308}, doi = {10.1145/3477314.3507308}, booktitle = {Proceedings of the 37th ACM/SIGAPP Symposium on Applied Computing (SAC)}, publisher = {ACM}, author = {Stiévenart, Quentin and De Roover, Coen and Ghafari, Mohammad}, year = {2022}, month = apr, pages = {1713–1722}, collection = {SAC ’22} }
Summary-Based Compositional Analysis for Soft Contract Verification

Bram Vandenbogaerde, Quentin Stievenart, and Coen De Roover

In 2022 IEEE 22nd International Working Conference on Source Code Analysis and Manipulation (SCAM), Oct 2022

Best Artifact Award Abs DOI Bib PDF

Best Artifact Award, SCAM 2022.

Design-by-contract is a development best practice that requires the interactions between software components to be governed by precise specifications, called contracts. Contracts often take the form of pre- and post-conditions on function definitions, and are usually translated to (frequently redundant) run-time checks. So-called soft contract verifiers have been proposed to reduce the run-time overhead introduced by such contract checks by verifying parts of the contracts ahead of time, while leaving those that cannot be verified as residual runtime checks. In the state of the art, static analyses based on the Abstracting Abstract Machines (AAM) approach to abstract interpretation have been proposed for implementing such soft verifiers. However, these approaches result in whole-program analyses which are difficult to scale. In this paper, we propose a scalable summary-based compositional analysis for soft contract verification, which summarises both the correct behaviour and erroneous behaviour of all functions in the program using symbolic path conditions. Information from these summaries propagates backwards through the call graph, reducing the amount of redundant analysis states and improving the overall performance of the analysis. This backwards flow enables path constraints associated with erroneous program states to flow to call sites where they can be refuted, whereas in the state of the art they can only be refuted using the information available at the original location of the error. To demonstrate our improvements in both precision and performance compared to the state-of-the-art, we implemented our analysis in a framework called MAF (short for Modular Analysis Framework) — a framework for the analysis of higher-order dynamic programming languages. We conducted an empirical study and found an average performance improvement of 21%, and an average precision improvement of 38.15%.
@inproceedings{Vandenbogaerde2022Summary, title = {Summary-Based Compositional Analysis for Soft Contract Verification}, url = {http://dx.doi.org/10.1109/SCAM55253.2022.00028}, doi = {10.1109/scam55253.2022.00028}, booktitle = {2022 IEEE 22nd International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Vandenbogaerde, Bram and Stievenart, Quentin and De Roover, Coen}, year = {2022}, month = oct, pages = {186–196} }
LiFUSO: A Tool for Library Feature Unveiling based on Stack Overflow Posts

Camilo Velazquez-Rodriguez, Eleni Constantinou, and Coen De Roover

In 2022 IEEE International Conference on Software Maintenance and Evolution (ICSME), Oct 2022

Abs DOI Bib PDF

Selecting a library from a vast ecosystem can be a daunting task. The libraries are not only numerous, but they also lack an enumeration of the features they offer. A feature enumeration for each library in an ecosystem would help developers select the most appropriate library for the task at hand. Within this enumeration, a library feature could take the form of a brief description together with the API references through which the feature can be reused. This paper presents LiFUSO, a tool that leverages Stack Overflow posts to compute a list of such features for a given library. Each feature corresponds to a cluster of related API references based on the similarity of the Stack Overflow posts in which they occur. Once LiFUSO has extracted such a cluster of posts, it applies natural language processing to describe the corresponding feature. We describe the engineering aspects of the tool, and illustrate its usage through a preliminary case study in which we compare the features uncovered for two competing libraries within the same domain.
@inproceedings{VelazquezRodriguez2022LiFUSO, title = {LiFUSO: A Tool for Library Feature Unveiling based on Stack Overflow Posts}, url = {http://dx.doi.org/10.1109/ICSME55016.2022.00065}, doi = {10.1109/icsme55016.2022.00065}, booktitle = {2022 IEEE International Conference on Software Maintenance and Evolution (ICSME)}, publisher = {IEEE}, author = {Velazquez-Rodriguez, Camilo and Constantinou, Eleni and De Roover, Coen}, year = {2022}, month = oct, pages = {489–493} }
Uncovering Library Features from API Usage on Stack Overflow

Camilo Velazquez-Rodriguez, Eleni Constantinou, and Coen De Roover

In 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), Mar 2022

Distinguished Paper Award Abs DOI Bib PDF

IEEE Computer Society TCSE Distinguished Paper Award, SANER 2022.

Selecting an appropriate library for reuse within a vast software ecosystem can be a daunting task. A list of features for each library, i.e., a short description of the functionality that can be reused with code examples that illustrate its usage, may alleviate this problem. In this paper, we propose a data-driven approach that uses both the code snippets and the accompanying natural language descriptions from Stack Overflow posts to produce a list of features of a given library. Each extracted feature corresponds to a cluster of API classes and methods considered related based on attributes of the Stack Overflow posts in which they appear. We evaluated the approach considering seven Maven libraries and compared the resulting features against library descriptions from cookbook-like tutorials. The approach achieves an average accuracy of 67% across the seven libraries for the tutorial-like features. For at least 73% of the features extracted by the approach but missing from the documentation, we found a matching library usage in a corpus of GitHub projects. These results suggest that our clusters represent library features, which paves the way to better tool support for documenting software libraries and for selecting a library in an ecosystem.
@inproceedings{VelazquezRodriguez2022Uncovering, title = {Uncovering Library Features from API Usage on Stack Overflow}, url = {http://dx.doi.org/10.1109/SANER53432.2022.00035}, doi = {10.1109/saner53432.2022.00035}, booktitle = {2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)}, publisher = {IEEE}, author = {Velazquez-Rodriguez, Camilo and Constantinou, Eleni and De Roover, Coen}, year = {2022}, month = mar, pages = {207–217} }

2021

Andromeda: A Dataset of Ansible Galaxy Roles and Their Evolution

Ruben Opdebeeck, Ahmed Zerouali, and Coen De Roover

In 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR), May 2021

Abs DOI Bib PDF

Cloud-native applications increasingly provision infrastructure resources programmatically through Infrastructure as Code (IaC) scripts. These scripts have in turn become the subject of empirical software engineering research. However, an often-overlooked part are the software ecosystems that have grown around the IaC languages. For example, Galaxy is an ecosystem for the popular Ansible IaC language. Galaxy features a large number of so-called “roles”, which are reusable collections of Ansible code akin to libraries for general-purpose languages. In contrast to, and despite their similarities, such IaC ecosystems have enjoyed far less attention in the literature than library ecosystems for general-purpose languages. In this data showcase paper, we present Andromeda, the first dataset capturing the Ansible Galaxy ecosystem, its roles, and their evolution. Andromeda provides structural representations of more than 125000 role versions, and upwards of 800000 concrete changes between such versions extracted from the un- derlying git repositories. Andromeda aims to provide an extensive view of the contributor side of the Galaxy ecosystem, which we hope will stimulate additional research on IaC ecosystems.
@inproceedings{Opdebeeck2021Andromeda, title = {Andromeda: A Dataset of Ansible Galaxy Roles and Their Evolution}, url = {http://dx.doi.org/10.1109/MSR52588.2021.00078}, doi = {10.1109/msr52588.2021.00078}, booktitle = {2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR)}, publisher = {IEEE}, author = {Opdebeeck, Ruben and Zerouali, Ahmed and De Roover, Coen}, year = {2021}, month = may, pages = {580–584} }
QSES: Quasi-Static Executable Slices

Quentin Stievenart, David Binkley, and Coen De Roover

In 2021 IEEE 21st International Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2021

Abs DOI Bib PDF

Program slicing aims to reduce a program to a minimal form that produces the same output for a given slicing criterion. Program slicing approaches divide into static and dynamic approaches: whereas static approaches generate an over- approximation of the slice that is valid for all possible program inputs, dynamic approaches rely on executing the program and thus generate an under-approximation of the slice that is valid for only a subset of the inputs. An important limitation of static approaches is that they often do not generate an executable program, but rather identify only those program components upon which the slicing criterion depends (referred to as a closure slice). In order to overcome this limitation, we propose a novel approach that combines static and dynamic slicing. We rely on observation-based slicing, a dynamic approach, but protect all statements that have been identiﬁed as part of the static slice by the static slicer CodeSurfer. As a result, we obtain slices that cover at least the behavior of the static slice, but that can be compiled and executed. We evaluated this new approach on a set of 57 C programs and report our preliminary ﬁndings.
@inproceedings{Stievenart2021QSES, title = {QSES: Quasi-Static Executable Slices}, url = {http://dx.doi.org/10.1109/SCAM52516.2021.00033}, doi = {10.1109/scam52516.2021.00033}, booktitle = {2021 IEEE 21st International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Stievenart, Quentin and Binkley, David and De Roover, Coen}, year = {2021}, month = sep, pages = {209–213} }
The Security Risk of Lacking Compiler Protection in WebAssembly

Quentin Stiévenart, Coen De Roover, and Mohammad Ghafari

In 2021 IEEE 21st International Conference on Software Quality, Reliability and Security (QRS), Dec 2021

Abs DOI Bib PDF

WebAssembly is increasingly used as the compilation target for cross-platform applications. In this paper, we investigate whether one can rely on the security measures enforced by existing C compilers when compiling C programs to WebAssembly. We compiled 4,469 C programs with known buffer overflow vulnerabilities to x86 code and to WebAssembly, and observed the outcome of the execution of the generated code to differ for 1,088 programs. Through manual inspection, we identified that the root cause for these is the lack of security measures such as stack canaries in the generated WebAssembly: while x86 code crashes upon a stack-based buffer overflow, the corresponding WebAssembly continues to be executed. We conclude that compiling an existing C program to WebAssembly without additional precautions may hamper its security, and we encourage more research in this direction.
@inproceedings{Stivenart2021Securityb, title = {The Security Risk of Lacking Compiler Protection in WebAssembly}, url = {http://dx.doi.org/10.1109/QRS54544.2021.00024}, doi = {10.1109/qrs54544.2021.00024}, booktitle = {2021 IEEE 21st International Conference on Software Quality, Reliability and Security (QRS)}, publisher = {IEEE}, author = {Stiévenart, Quentin and De Roover, Coen and Ghafari, Mohammad}, year = {2021}, month = dec, pages = {132–139} }
Identifying Versions of Libraries used in Stack Overflow Code Snippets

Ahmed Zerouali, Camilo Velazquez-Rodriguez, and Coen De Roover

In 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR), May 2021

Abs DOI Bib PDF

Stack Overflow is a popular question and answer platform where developers share technical issues in the hope of receiving answers with potential solutions. The latter may include code snippets making use of library versions that have long since been succeeded by newer ones. Other developers finding such a snippet at a later point in time may be unaware of its outdatedness unless mentioned in a comment. Furthermore, it can be difficult to integrate the snippet without knowing the exact version of the library it is referencing. In this paper, we propose an automated approach to identifying ranges of Maven library versions that might have been used in a Java snippet on Stack Overflow. We use a prototype implementation of the approach to assess the overall outdatedness of Stack Overflow snippets with respect to the latest version of each referenced library available from Maven. We found a considerable number of snippets that use outdated library versions, which suggests that developers should be careful when adopting solutions from Stack Overflow.
@inproceedings{Zerouali2021Identifying, title = {Identifying Versions of Libraries used in Stack Overflow Code Snippets}, url = {http://dx.doi.org/10.1109/MSR52588.2021.00046}, doi = {10.1109/msr52588.2021.00046}, booktitle = {2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR)}, publisher = {IEEE}, author = {Zerouali, Ahmed and Velazquez-Rodriguez, Camilo and De Roover, Coen}, year = {2021}, month = may, pages = {341–345} }
Mining for Graph-Based Library Usage Patterns in COBOL Systems

Ruben Opdebeeck, Johan Fabry, Tim Molderez, and 2 more authors

In 2021 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), Mar 2021

Abs DOI Bib PDF

When migrating legacy systems to more contemporary platforms, it is not always feasible to migrate their external library dependencies as well. A workaround can be to partially reimplement the library dependencies on the new platform, limiting oneself to the features that are used by the migrated system. For contemporary programming languages, several approaches to mining for library usage patterns have been proposed. For legacy programming languages, in contrast, such tools are lacking. This encumbers establishing what parts of a library need to be rewritten during a migration project, especially when considering large-scale systems. In this industry track paper, we present an approach to mining library usage patterns in COBOL code. We describe a library usage extractor for COBOL, which produces graphs that capture the control and data flow involved in library calls. The extractor supports legacy control flow features, such as GO TO. We use these graphs as input to two state-of-the-art frequent subgraph mining algorithms, and report on the scalability of their use for mining common library usage patterns in two industrial COBOL systems. The mined library usage patterns can help assess and subsequently steer the migration effort.
@inproceedings{Opdebeeck2021Mining, title = {Mining for Graph-Based Library Usage Patterns in COBOL Systems}, url = {http://dx.doi.org/10.1109/SANER50967.2021.00072}, doi = {10.1109/saner50967.2021.00072}, booktitle = {2021 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)}, publisher = {IEEE}, author = {Opdebeeck, Ruben and Fabry, Johan and Molderez, Tim and De Bleser, Jonas and De Roover, Coen}, year = {2021}, month = mar, pages = {595–599} }

2020

A Delta-Debugging Approach to Assessing the Resilience of Actor Programs through Run-time Test Perturbations

Jonas De Bleser, Dario Di Nucci, and Coen De Roover

In Proceedings of the IEEE/ACM 1st International Conference on Automation of Software Test (AST), Oct 2020

Abs DOI Bib PDF

Among distributed applications, the actor model is increasingly prevalent. This programming model organises applications into fully-isolated processes that communicate through asynchronous messaging. Supported by frameworks such as Akka and Orleans, it is believed to facilitate realising responsive, elastic and resilient distributed applications. While these frameworks do provide abstractions for implementing resilience, it remains up to developers to use them correctly and to test that their implementation actually recovers from anticipated failures. As manually exploring the reaction to every possible failure scenario is infeasible, there is a need for automated means of testing the resilience of a distributed application. We present the first automated approach to testing the resilience of actor programs. Our approach perturbs the execution of existing test cases and leverages delta debugging to explore all failure scenarios more efficiently. Moreover, we present a further optimisation that uses causality to prune away redundant perturbations and speed up the exploration. However, its effectiveness is sensitive to the program’s organisation and to the actual location of the fault. Our experimental evaluation shows that our approach can speed up resilience testing by four times compared to random exploration.
@inproceedings{DeBleser2020Delta, series = {AST ’20}, title = {A Delta-Debugging Approach to Assessing the Resilience of Actor Programs through Run-time Test Perturbations}, url = {http://dx.doi.org/10.1145/3387903.3389303}, doi = {10.1145/3387903.3389303}, booktitle = {Proceedings of the IEEE/ACM 1st International Conference on Automation of Software Test (AST)}, publisher = {ACM}, author = {De Bleser, Jonas and Di Nucci, Dario and De Roover, Coen}, year = {2020}, month = oct, pages = {21–30}, collection = {AST ’20} }
Compositional Information Flow Analysis for WebAssembly Programs

Quentin Stievenart and Coen De Roover

In 2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2020

Abs DOI Bib PDF

WebAssembly is a new W3C standard, providing a portable target for compilation for various languages. All major browsers can run WebAssembly programs, and its use extends beyond the web: there is interest in compiling cross-platform desktop applications, server applications, IoT and embedded applications to WebAssembly because of the performance and security guarantees it aims to provide. Indeed, WebAssembly has been carefully designed with security in mind. In particular, WebAssembly applications are sandboxed from their host environment. However, recent works have brought to light several limitations that expose WebAssembly to traditional attack vectors. Visitors of websites using WebAssembly have been exposed to malicious code as a result. In this paper, we propose an automated static program analysis to address these security concerns. Our analysis is focused on information flow and is compositional. For every WebAssembly function, it first computes a summary that describes in a sound manner where the information from its parameters and the global program state can flow to. These summaries can then be applied during the subsequent analysis of function calls. Through a classical fixed-point formulation, one obtains an approximation of the information flow in the WebAssembly program. This results in the first compositional static analysis for WebAssembly. On a set of 34 benchmark programs spanning 196kLOC of WebAssembly, we compute at least 64% of the function summaries precisely in less than a minute in total.
@inproceedings{Stievenart2020Compositional, title = {Compositional Information Flow Analysis for WebAssembly Programs}, url = {http://dx.doi.org/10.1109/SCAM51674.2020.00007}, doi = {10.1109/scam51674.2020.00007}, booktitle = {2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Stievenart, Quentin and Roover, Coen De}, year = {2020}, month = sep, pages = {13–24} }
A Parallel Worklist Algorithm for Modular Analyses

Noah Van Es, Quentin Stievenart, Jens Plas, and 1 more author

In 2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2020

Abs DOI Bib PDF

One way to speed up static program analysis is to make use of today’s multi-core CPUs by parallelising the analysis. Existing work on parallel analysis usually targets traditional data-flow analyses for static, first-order languages such as C. Less attention has been given so far to the parallelisation of more general analyses that can also target dynamic, higher-order languages such as JavaScript. These are significantly more challenging to parallelise, as dependencies between analysis results are only discovered during the analysis itself. State-of-the-art parallel analyses for such languages are therefore usually limited, both in their applicability and performance gains. In this work, we propose the parallelisation of modular analyses. Modular analyses compute different parts of the analysis in isolation of one another, and therefore offer inherent opportunities for parallelisation that have not been explored so far. In addition, they can be used to develop a general class of analysers for dynamic, higher-order languages. We present a parallel variant of the worklist algorithm that is used to drive such modular analyses. To further speed up its convergence, we show how this algorithm can exploit the monotonicity of the analysis. Existing modular analyses can be parallelised without additional effort by instead employing this parallel worklist algorithm. We demonstrate this for ModF, an inter-procedural modular analysis, and for ModConc, an inter-process modular analysis. For ModConc, we reveal an additional opportunity to exploit even more parallelism in the analysis. Our parallel worklist algorithm is implemented and integrated into MAF, a framework for modular program analysis. Using a set of Scheme benchmarks for ModF, we usually observe speedups between 3x and 8x when using 4 workers, and speedups between 8x and 32x when using 16 workers. For ModConc, we achieve a maximum speedup of 15x.
@inproceedings{VanEs2020Parallel, title = {A Parallel Worklist Algorithm for Modular Analyses}, url = {http://dx.doi.org/10.1109/SCAM51674.2020.00006}, doi = {10.1109/scam51674.2020.00006}, booktitle = {2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Van Es, Noah and Stievenart, Quentin and Van der Plas, Jens and De Roover, Coen}, year = {2020}, month = sep, pages = {1–12} }
MAF: A Framework for Modular Static Analysis of Higher-Order Languages

Noah Van Es, Jens Plas, Quentin Stievenart, and 1 more author

In 2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2020

Abs DOI Bib PDF

A modular static analysis decomposes a program’s analysis into analyses of its parts, or components. An inter-component analysis instructs an intra-component analysis to analyse each component independently of the others. Additional analyses are scheduled for newly discovered components, and for dependent components that need to account for newly discovered component information. Modular static analyses are scalable, can be tuned to a high precision, and support the analysis of programs that are highly dynamic, featuring e.g., higher-order functions or dynamically allocated processes. In this paper, we present the engineering aspects of MAF, a static analysis framework for implementing modular analyses for higher-order languages. For any such modular analysis, the framework provides a reusable inter-component analysis and it suffices to implement its intra-component analysis. The intra-component analysis can be composed from several interdependent and reusable Scala traits. This design facilitates changing the analysed language, as well as the analysis precision with minimal effort. We illustrate the use of MAF through its instantiation for several different analyses of Scheme programs.
@inproceedings{VanEs2020MAF, title = {MAF: A Framework for Modular Static Analysis of Higher-Order Languages}, url = {http://dx.doi.org/10.1109/SCAM51674.2020.00009}, doi = {10.1109/scam51674.2020.00009}, booktitle = {2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Van Es, Noah and Van der Plas, Jens and Stievenart, Quentin and De Roover, Coen}, year = {2020}, month = sep, pages = {37–42} }
Incremental Flow Analysis through Computational Dependency Reification

Jens Plas, Quentin Stievenart, Noah Van Es, and 1 more author

In 2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2020

Abs DOI Bib PDF

Static analyses are used to gain more confidence in changes made by developers. To be of most use, such analyses must deliver feedback fast. Therefore, incremental static analyses update previous results rather than entirely recompute them. This reduces the analysis time upon a program change, and makes the analysis well-suited for environments where the codebase is frequently updated, such as in IDEs and CI pipelines. In this work, we present a general approach to render a modular static analysis for highly dynamic programs incremental, by exploiting dependencies between intermediate analysis results. Modular analyses divide a program in interdependent parts that are analysed in isolation. The dependencies between these parts stem, for example, from the use of shared variables within the program. Our incrementalisation approach leverages the modularity of the analysis together with the dependencies that it reifies to compute and bound the impact of changes. This way, only the affected parts of the result need to be reanalysed, and unnecessary recomputations are avoided. We apply our approach to both a function-modular and thread-modular analysis and evaluate it by comparing an incremental update of an existing result to a full reanalysis. We find reductions of the analysis time from 6% to 99% on 14 out of 16 benchmark programs, and on most programs the impact on precision is limited. On 7 of the programs, reanalysis time is reduced by more than 75%, showing that our approach results in fast incremental updates.
@inproceedings{VanderPlas2020Incremental, title = {Incremental Flow Analysis through Computational Dependency Reification}, url = {http://dx.doi.org/10.1109/SCAM51674.2020.00008}, doi = {10.1109/scam51674.2020.00008}, booktitle = {2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Van der Plas, Jens and Stievenart, Quentin and Van Es, Noah and De Roover, Coen}, year = {2020}, month = sep, pages = {25–36} }
MUTAMA: An Automated Multi-label Tagging Approach for Software Libraries on Maven

Camilo Velazquez-Rodriguez and Coen De Roover

In 2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2020

Abs DOI Bib PDF

Recent studies show that the Maven ecosystem alone already contains over 2 million library artefacts including their source code, byte code, and documentation. To help developers cope with this information, several websites overlay configurable views on the ecosystem. For instance, views in which similar libraries are grouped into categories or views showing all libraries that have been tagged with tags corresponding to coarse-grained library features. The MVNRepository overlay website offers both category-based and tag-based views. Unfortunately, several libraries have not been categorised or are missing relevant tags. Some initial approaches to the automated categorisation of Maven libraries have already been proposed. However, no such approach exists for the problem of tagging of libraries in a multi-label setting. This paper proposes MUTAMA, a multi-label classification approach to the Maven library tagging problem based on information extracted from the byte code of each library. We analysed 4088 randomly selected libraries from the Maven software ecosystem. MUTAMA trains and deploys five multi-label classifiers using feature vectors obtained from class and method names of the tagged libraries. Our results indicate that classifiers based on ensemble methods achieve the best performances. Finally, we propose directions to follow in this area.
@inproceedings{VelazquezRodriguez2020MUTAMA, title = {MUTAMA: An Automated Multi-label Tagging Approach for Software Libraries on Maven}, url = {http://dx.doi.org/10.1109/SCAM51674.2020.00034}, doi = {10.1109/scam51674.2020.00034}, booktitle = {2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Velazquez-Rodriguez, Camilo and De Roover, Coen}, year = {2020}, month = sep, pages = {254–258} }
Automatic library categorization

Camilo Velázquez-Rodríguez and Coen De Roover

In Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops, Jun 2020

Abs DOI Bib

Software ecosystems contain several types of artefacts such as libraries, documentation and source code files. Recent studies show that the Maven software ecosystem alone already contains over 2.8 million artefacts and over 70, 000 libraries. Given the size of the ecosystem, selecting a library represents a challenge to its users. The MVNRepository website offers a category-based search func- tionality as a solution. However, not all of the libraries have been categorised, which leads to incomplete search results. This work proposes an approach to the automatic categorisation of libraries through machine learning classifiers trained on class and method names. Our preliminary results show that the approach is accurate, suggesting that large-scale applications may be feasible.
@inproceedings{VelzquezRodrguez2020Automatic, series = {ICSE ’20}, title = {Automatic library categorization}, url = {http://dx.doi.org/10.1145/3387940.3392186}, doi = {10.1145/3387940.3392186}, booktitle = {Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops}, publisher = {ACM}, author = {Velázquez-Rodríguez, Camilo and De Roover, Coen}, year = {2020}, month = jun, pages = {733–734}, collection = {ICSE ’20} }
Does Infrastructure as Code Adhere to Semantic Versioning? An Analysis of Ansible Role Evolution

Ruben Opdebeeck, Ahmed Zerouali, Camilo Velazquez-Rodriguez, and 1 more author

In 2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2020

Abs DOI Bib PDF

Ansible, a popular Infrastructure-as-Code platform, provides reusable collections of tasks called roles. Roles are often contributed by third parties, and like general-purpose libraries, they evolve. As such, new releases of roles need to be tagged with version numbers, for which Ansible recommends adhering to the semantic versioning format. However, roles significantly differ from general-purpose libraries, and it is not yet known what constitutes a breaking change or the addition of a feature to a role. Consequently, this can cause confusion for clients of a role and new role contributors. To alleviate this issue, we perform an empirical study on semantic versioning in Ansible roles to uncover the types of changes that trigger certain types of version bumps. We collect a dataset of over 70 000 version increments spanning upwards of 7 800 Ansible roles. Moreover, we design a novel structural model for these roles, and implement a domain-specific structural change extraction algorithm to calculate structural difference metrics. Afterwards, we quantitatively investigate the state of semantic versioning in Ansible roles and identify the most commonly changed components. Then, using the structural difference metrics, we train a Random Forest classifier to predict applicable version bumps for Ansible role releases. Lastly, we confirm our empirical findings with a developer survey. Our observations show that although most Ansible role developers follow the semantic versioning format, it appears that they do not always consistently follow the same rules when selecting the version bump to apply.
@inproceedings{Opdebeeck2020Does, title = {Does Infrastructure as Code Adhere to Semantic Versioning? An Analysis of Ansible Role Evolution}, url = {http://dx.doi.org/10.1109/SCAM51674.2020.00032}, doi = {10.1109/scam51674.2020.00032}, booktitle = {2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Opdebeeck, Ruben and Zerouali, Ahmed and Velazquez-Rodriguez, Camilo and Roover, Coen De}, year = {2020}, month = sep, pages = {238–248} }

2019

Mining Scala Framework Extensions for Recommendation Patterns

Yunior Pacheco, Jonas De Bleser, Tim Molderez, and 3 more authors

In 2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER), Feb 2019

Abs DOI Bib PDF

To use a framework, developers often need to hook into and customise some of its functionality. For example, a common way of customising a framework is to subclass a framework type and to override some of its methods. Recently, Asaduzzaman et al. defined these customisations as extension points and proposed a new approach to mine large amounts of Java code examples and recommend the most frequently used example, so called extension patterns. Indeed, recommending extension patterns that frequently occur at such extension points can help developers to adopt a new framework correctly and to fully exploit it. In this paper, we present a differentiated replication study of the work by Asaduzzaman et al. on Java frameworks. Our aim is to replicate the work in order to analyse extension points and extension patterns in the context of Scala frameworks. To this aim, we propose SCALA-XP-MINER, a tool for mining extension patterns in Scala software systems to empirically investigate our hypotheses. Our results show that the approach proposed by the reference work is also able to mine extension patterns for Scala frameworks and that our tool is able to achieve similar precision, recall and F-Measure compared to FEMIR. Despite this, the distribution of the extension points by category is different and most of the patterns are rather simple. Thus, the challenge of recommending more complex patterns to Scala developers is still an open problem.
@inproceedings{Pacheco2019Mining, title = {Mining Scala Framework Extensions for Recommendation Patterns}, url = {http://dx.doi.org/10.1109/SANER.2019.8668019}, doi = {10.1109/saner.2019.8668019}, booktitle = {2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER)}, publisher = {IEEE}, author = {Pacheco, Yunior and Bleser, Jonas De and Molderez, Tim and Nucci, Dario Di and Meuter, Wolfgang De and Roover, Coen De}, year = {2019}, month = feb, pages = {514–523} }
SoCRATES: Scala radar for test smells

Jonas De Bleser, Dario Di Nucci, and Coen De Roover

In Proceedings of the Tenth ACM SIGPLAN Symposium on Scala (Scala), Jul 2019

Abs DOI Bib PDF

Test smells are indications of poorly designed unit tests. Previous studies have demonstrated their negative impact on test understanding and maintenance. Moreover, surveys show that developers are not able to identify test smells, hindering optimal software quality. Automated tools can aid developers to handle these issues and detect test smells in the early stage of software development. However, few tools are publicly available and all of them target JUnit – the most popular testing framework in Java. To overcome these limitations, we propose SoCRATES. This fully automated tool is able to identify six test smells in Scala Test which is the most prevalent testing framework in Scala. An empirical investigation on 164 Scala projects shows that our tool is able to reach a high precision without sacrificing recall. Moreover, the results show that Scala projects have a lower diffusion than Java projects. We make SoCRATES publicly available as an IntelliJ IDEA plugin, as well as an open-source project in order to facilitate the detection of test smells.
@inproceedings{DeBleser2019SoCRATES, series = {Scala ’19}, title = {SoCRATES: Scala radar for test smells}, url = {http://dx.doi.org/10.1145/3337932.3338815}, doi = {10.1145/3337932.3338815}, booktitle = {Proceedings of the Tenth ACM SIGPLAN Symposium on Scala (Scala)}, publisher = {ACM}, author = {De Bleser, Jonas and Di Nucci, Dario and De Roover, Coen}, year = {2019}, month = jul, pages = {22–26}, collection = {Scala ’19} }
Assessing Diffusion and Perception of Test Smells in Scala Projects

Jonas De Bleser, Dario Di Nucci, and Coen De Roover

In 2019 IEEE/ACM 16th International Conference on Mining Software Repositories (MSR), May 2019

Abs DOI Bib PDF

Test smells are, analogously to code smells, defined as the characteristics exhibited by poorly designed unit tests. Their negative impact on test effectiveness, understanding, and maintenance has been demonstrated by several empirical studies. However, the scope of these studies has been limited mostly to JAVA in combination with the JUNIT testing framework. Results for other language and framework combinations are —despite their prevalence in practice— few and far between, which might skew our understanding of test smells. The combination of Scala and ScalaTest, for instance, offers more comprehensive means for defining and reusing test fixtures, thereby possibly reducing the diffusion and perception of fixture-related test smells. This paper therefore reports on two empirical studies conducted for this combination. In the first study, we analyse the tests of 164 open-source Scala projects hosted on GitHub for the diffusion of test smells. This required the transposition of their original definition to this new context, and the implementation of a tool (SoCRATES) for their automated detection. In the second study, we assess the perception and the ability of 14 Scala developers to identify test smells. For this context, our results show (i) that test smells have a low diffusion across test classes, (ii) that the most frequently occurring test smells are Lazy Test, Eager Test, and Assertion Roulette, and (iii) that many developers were able to perceive but not to identify the smells.
@inproceedings{DeBleser2019Assessing, title = {Assessing Diffusion and Perception of Test Smells in Scala Projects}, url = {http://dx.doi.org/10.1109/MSR.2019.00072}, doi = {10.1109/msr.2019.00072}, booktitle = {2019 IEEE/ACM 16th International Conference on Mining Software Repositories (MSR)}, publisher = {IEEE}, author = {De Bleser, Jonas and Di Nucci, Dario and De Roover, Coen}, year = {2019}, month = may, pages = {457–467} }
Marlon: a domain-specific language for multi-agent reinforcement learning on networks

Tim Molderez, Bjarno Oeyen, Coen De Roover, and 1 more author

In Proceedings of the 34th ACM/SIGAPP Symposium on Applied Computing (SAC), Apr 2019

Abs DOI Bib PDF

Distributed systems can consist of thousands of network nodes interacting with each other. Given their size, managing these systems to perform optimally is a task that should be automated. Multi-agent reinforcement learning (MARL) is a suitable technique for tackling such problems. However, the application of MARL in a distributed system is not trivial. To bridge the gap between these two domains, we introduce the Marlon language. It enables MARL experts to focus on solving machine learning problems, rather than the complexities of distributed computing. We evaluate Marlon by comparing the implementation of a load balancing use case in Marlon with an ad-hoc implementation.
@inproceedings{Molderez2019Marlon, series = {SAC ’19}, title = {Marlon: a domain-specific language for multi-agent reinforcement learning on networks}, url = {http://dx.doi.org/10.1145/3297280.3297413}, doi = {10.1145/3297280.3297413}, booktitle = {Proceedings of the 34th ACM/SIGAPP Symposium on Applied Computing (SAC)}, publisher = {ACM}, author = {Molderez, Tim and Oeyen, Bjarno and De Roover, Coen and De Meuter, Wolfgang}, year = {2019}, month = apr, pages = {1322–1329}, collection = {SAC ’19} }
Effect-Driven Flow Analysis

Jens Nicolay, Quentin Stiévenart, Wolfgang De Meuter, and 1 more author

In Verification, Model Checking, and Abstract Interpretation (VMCAI), 2019

Abs DOI Bib PDF

Traditional machine-based static analyses use a worklist algorithm to explore the analysis state space, and compare each state in the worklist against a set of seen states as part of their fixed-point computation. This may require many state comparisons, which gives rise to a computational overhead. Even an analysis with a global store has to clear its set of seen states each time the store updates because of allocation or side-effects, which results in more states being reanalyzed and compared. In this work we present a static analysis technique, ModF, that does not rely on a set of seen states, and apply it to a machine-based analysis with global-store widening. Modf analyzes one function execution at a time to completion while tracking read, write, and call effects. These effects trigger the analysis of other function executions, and the analysis terminates when no new effects can be discovered. We compared Modf to a traditional machine-based analysis implementation on a set of 20 benchmark programs and found that Modf is faster for 17 programs with speedups ranging between 1.4x and 12.3x. Furthermore, Modf exhibits similar precision as the traditional analysis on most programs and yields state graphs that are comparable in size.
@incollection{Nicolay2019Effect, title = {Effect-Driven Flow Analysis}, isbn = {9783030112455}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-030-11245-5_12}, doi = {10.1007/978-3-030-11245-5_12}, booktitle = {Verification, Model Checking, and Abstract Interpretation (VMCAI)}, publisher = {Springer International Publishing}, author = {Nicolay, Jens and Stiévenart, Quentin and De Meuter, Wolfgang and De Roover, Coen}, year = {2019}, pages = {247–274} }
Mining Patterns in Source Code Using Tree Mining Algorithms

Hoang Son Pham, Siegfried Nijssen, Kim Mens, and 5 more authors

In Discovery Science (DS), 2019

Abs DOI Bib PDF

Discovering regularities in source code is of great interest to software engineers, both in academia and in industry, as regularities can provide useful information to help in a variety of tasks such as code comprehension, code refactoring, and fault localisation. However, traditional pattern mining algorithms often find too many patterns of little use and hence are not suitable for discovering useful regularities. In this paper we propose FREQTALS, a new algorithm for mining patterns in source code based on the FREQT tree mining algorithm. First, we introduce several constraints that effectively enable us to find more useful patterns; then, we show how to efficiently include them in FREQT. To illustrate the usefulness of the constraints we carried out a case study in collaboration with software engineers, where we identified a number of interesting patterns in a repository of Java code.
@incollection{Pham2019Mining, title = {Mining Patterns in Source Code Using Tree Mining Algorithms}, isbn = {9783030337780}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-030-33778-0_35}, doi = {10.1007/978-3-030-33778-0_35}, booktitle = {Discovery Science (DS)}, publisher = {Springer International Publishing}, author = {Pham, Hoang Son and Nijssen, Siegfried and Mens, Kim and Di Nucci, Dario and Molderez, Tim and De Roover, Coen and Fabry, Johan and Zaytsev, Vadim}, year = {2019}, pages = {471–480} }
GUARDIAML: Machine Learning-Assisted Dynamic Information Flow Control

Angel Luis Scull Pupo, Jens Nicolay, Kyriakos Efthymiadis, and 3 more authors

In 2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER), Feb 2019

Abs DOI Bib PDF

Developing JavaScript and web applications with confidentiality and integrity guarantees is challenging. Information flow control enables the enforcement of such guarantees. However, the integration of this technique into software tools used by developers in their workflow is missing. In this paper we present GuardiaML, a machine learning-assisted dynamic information flow control tool for JavaScript web applications. GuardiaML enables developers to detect unwanted information flow from sensitive sources to public sinks. It can handle the DOM and interaction with internal and external libraries and services. Because the specification of sources and sinks can be tedious, GuardiaML assists in this process by suggesting the tagging of sources and sinks via a machine learning component.
@inproceedings{Pupo2019GUARDIAML, title = {GUARDIAML: Machine Learning-Assisted Dynamic Information Flow Control}, url = {http://dx.doi.org/10.1109/SANER.2019.8667979}, doi = {10.1109/saner.2019.8667979}, booktitle = {2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER)}, publisher = {IEEE}, author = {Pupo, Angel Luis Scull and Nicolay, Jens and Efthymiadis, Kyriakos and Nowe, Ann and Roover, Coen De and Boix, Elisa Gonzalez}, year = {2019}, month = feb, pages = {624–628} }
Garbage-Free Abstract Interpretation Through Abstract Reference Counting

Noah Van Es, Quentin Stiévenart, and Coen De Roover

In 33rd European Conference on Object-Oriented Programming (ECOOP 2019), 2019

Abs DOI Bib PDF

Abstract garbage collection is the application of garbage collection to an abstract interpreter. Existing work has shown that abstract garbage collection can improve both the interpreter’s precision and performance. Current approaches rely on heuristics to decide when to apply abstract garbage collection. Garbage will build up and impact precision and performance when the collection is applied infrequently, while too frequent applications will bring about their own performance overhead. A balance between these tradeoffs is often difficult to strike. We propose a new approach to cope with the buildup of garbage in the results of an abstract interpreter. Our approach is able to eliminate all garbage, therefore obtaining the maximum precision and performance benefits of abstract garbage collection. At the same time, our approach does not require frequent heap traversals, and therefore adds little to the interpreters’s running time. The core of our approach uses reference counting to detect and eliminate garbage as soon as it arises. However, reference counting cannot deal with cycles, and we show that cycles are much more common in an abstract interpreter than in its concrete counterpart. To alleviate this problem, our approach detects cycles and employs reference counting at the level of strongly connected components. While this technique in general works for any system that uses reference counting, we argue that it works particularly well for an abstract interpreter. In fact, we show formally that for the continuation store, where most of the cycles occur, the cycle detection technique only requires O(1) amortized operations per continuation push. We present our approach formally, and provide a proof-of-concept implementation in the Scala-AM framework. We empirically show our approach achieves both the optimal precision and significantly better performance compared to existing approaches to abstract garbage collection.
@inproceedings{VanEs2019Garbage, doi = {10.4230/LIPICS.ECOOP.2019.10}, url = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2019.10}, author = {Van Es, Noah and Stiévenart, Quentin and De Roover, Coen}, keywords = {abstract interpretation, abstract garbage collection, reference counting, Theory of computation → Program analysis}, language = {en}, title = {Garbage-Free Abstract Interpretation Through Abstract Reference Counting}, booktitle = {33rd European Conference on Object-Oriented Programming (ECOOP 2019)}, series = {LIPIcs}, volume = {134}, pages = {10:1-10:33}, publisher = {Schloss Dagstuhl – Leibniz-Zentrum für Informatik}, year = {2019}, copyright = {Creative Commons Attribution 3.0 Unported license} }

2018

[Research Paper] Untangling Composite Commits Using Program Slicing

Ward Muylaert and Coen De Roover

In 2018 IEEE 18th International Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2018

Abs DOI Bib PDF

Composite commits are a common mistake in the use of version control software. A composite commit groups many unrelated tasks, rendering the commit difficult for developers to understand, revert, or integrate and for empirical researchers to analyse. We propose an algorithmic foundation for tool support to identify such composite commits. Our algorithm computes both a program dependence graph and the changes to the abstract syntax tree for the files that have been changed in a commit. Our algorithm then groups these fine-grained changes according to the slices through the dependence graph they belong to. To evaluate our technique, we analyse and refine an established dataset of Java commits, the results of which we also make available. We find that our algorithm can determine whether or not a commit is composite. For the majority of commits, this analysis takes but a few seconds. The parts of a commit that our algorithm identifies do not map directly to the commit’s tasks. The parts tend to be smaller, but stay within their respective tasks.
@inproceedings{Muylaert2018Research, title = {[Research Paper] Untangling Composite Commits Using Program Slicing}, url = {http://dx.doi.org/10.1109/SCAM.2018.00030}, doi = {10.1109/scam.2018.00030}, booktitle = {2018 IEEE 18th International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Muylaert, Ward and De Roover, Coen}, year = {2018}, month = sep, pages = {193–202} }
Practical Information Flow Control for Web Applications

Angel Luis Scull Pupo, Laurent Christophe, Jens Nicolay, and 2 more authors

In Runtime Verification (RV), 2018

Abs DOI Bib PDF

Current browser-level security solutions do not provide a mechanism for information flow control (IFC) policies. As such, they need to be combined with language-based security approaches. Practical implementations for ICF enforcement remains a challenge when the full spectrum of web applications features is taken into account (i.e. JavaScript features, web APIs, DOM, portability, performance, etc.). In this work we develop Gifc, a permissive-upgrade-based inlined monitoring mechanism to detect unwanted information flow in web applications. Gifc covers a wide range of JavaScript features that give rise to implicit flows. In contrast to related work, Gifc also handles dynamic code evaluation online, and it features an API function model mechanism that enables information tracking through APIs calls. As a result, Gifc can handle information flows that use DOM nodes as channels of information. We validate Gifc by means of a benchmark suite from literature specifically designed for information flow verification, which we also extend. We compare Gifc qualitatively with respect to closest related work and show that Gifc performs better at detecting unwanted implicit flows.
@incollection{ScullPupo2018Practical, title = {Practical Information Flow Control for Web Applications}, isbn = {9783030037697}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-030-03769-7_21}, doi = {10.1007/978-3-030-03769-7_21}, booktitle = {Runtime Verification (RV)}, publisher = {Springer International Publishing}, author = {Scull Pupo, Angel Luis and Christophe, Laurent and Nicolay, Jens and de Roover, Coen and Gonzalez Boix, Elisa}, year = {2018}, pages = {372–388} }
Orchestrating dynamic analyses of distributed processes for full-stack JavaScript programs

Laurent Christophe, Coen De Roover, Elisa Gonzalez Boix, and 1 more author

In Proceedings of the 17th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE), Nov 2018

Abs DOI Bib PDF

Dynamic analyses are commonly implemented by instrumenting the program under analysis. Examples of such analyses for JavaScript range from checkers of user-defined invariants to concolic testers. For a full-stack JavaScript program, these analyses need to reason about the state of the client-side and server-side processes it is comprised of. Lifting a dynamic analysis so that it supports full-stack programs can be challenging. It involves distributed communication to maintain the analysis state across all processes, which has to be deadlock-free. In this paper, we advocate maintaining distributed analysis state in a centralized analysis process instead —which is communicated with from the processes under analysis. The approach is supported by a dynamic analysis platform that provides abstractions for this communication. We evaluate the approach through a case study. We use the platform to build a distributed origin analysis, capable of tracking the expressions from which values originate from across process boundaries, and deploy it on collaborative drawing application. The results show that our approach greatly simplifies the lifting process at the cost of a computational overhead. We deem this overhead acceptable for analyses intended for use at development time.
@inproceedings{Christophe2018Orchestrating, series = {GPCE ’18}, title = {Orchestrating dynamic analyses of distributed processes for full-stack JavaScript programs}, url = {http://dx.doi.org/10.1145/3278122.3278135}, doi = {10.1145/3278122.3278135}, booktitle = {Proceedings of the 17th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE)}, publisher = {ACM}, author = {Christophe, Laurent and De Roover, Coen and Boix, Elisa Gonzalez and De Meuter, Wolfgang}, year = {2018}, month = nov, pages = {107–118}, collection = {GPCE ’18} }
A generalized model for visualizing library popularity, adoption, and diffusion within a software ecosystem

Raula Gaikovina Kula, Coen De Roover, Daniel M. German, and 2 more authors

In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER), Mar 2018

Abs DOI Bib PDF

The popularity of super repositories such as Maven Central and the CRAN is a testament to software reuse activities in both open-source and commercial projects alike. However, several studies have highlighted the risks and dangers brought about by application developers keeping dependencies on outdated library versions. Intelligent mining of super repositories could reveal hidden trends within the corresponding software ecosystem and thereby provide valuable insights for such dependency-related decisions. In this paper, we propose the Software Universe Graph (SUG) Model as a structured abstraction of the evolution of software systems and their library dependencies over time. To demonstrate the SUG’s usefulness, we conduct an empirical study using 6,374 Maven artifacts and over 6,509 CRAN packages mined from their real-world ecosystems. Visualizations of the SUG model such as ‘library coexistence pairings’ and ‘dependents diffusion’ uncover popularity, adoption and diffusion patterns within each software ecosystem. Results show the Maven ecosystem as having a more conservative approach to dependency updating than the CRAN ecosystem.
@inproceedings{Kula2018generalized, title = {A generalized model for visualizing library popularity, adoption, and diffusion within a software ecosystem}, url = {http://dx.doi.org/10.1109/SANER.2018.8330217}, doi = {10.1109/saner.2018.8330217}, booktitle = {2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER)}, publisher = {IEEE}, author = {Kula, Raula Gaikovina and De Roover, Coen and German, Daniel M. and Ishio, Takashi and Inoue, Katsuro}, year = {2018}, month = mar, pages = {288–299} }

2017

Extracting executable transformations from distilled code changes

Reinout Stevens and Coen De Roover

In 2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER), Feb 2017

Abs DOI Bib PDF

Change distilling algorithms compute a sequence of fine-grained changes that, when executed in order, transform a given source AST into a given target AST. The resulting change sequences are used in the field of mining software repositories to study source code evolution. Unfortunately, detecting and specifying source code evolutions in such a change sequence is cumbersome. We therefore introduce a tool-supported approach that identifies minimal executable subsequences in a sequence of distilled changes that implement a particular evolution pattern, specified in terms of intermediate states of the AST that undergoes each change. This enables users to describe the effect of multiple changes, irrespective of their execution order, while ensuring that different change sequences that implement the same code evolution are recalled. Correspondingly, our evaluation is two-fold. Using examples, we demonstrate the expressiveness of specifying source code evolutions through intermediate ASTs. We also show that our approach is able to recall different implementation variants of the same source code evolution in open-source histories.
@inproceedings{Stevens2017Extracting, title = {Extracting executable transformations from distilled code changes}, url = {http://dx.doi.org/10.1109/SANER.2017.7884619}, doi = {10.1109/saner.2017.7884619}, booktitle = {2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER)}, publisher = {IEEE}, author = {Stevens, Reinout and De Roover, Coen}, year = {2017}, month = feb, pages = {171–181} }
Mailbox Abstractions for Static Analysis of Actor Programs

Quentin Stiévenart, Jens Nicolay, Wolfgang De Meuter, and 1 more author

In 31st European Conference on Object-Oriented Programming (ECOOP 2017), 2017

Abs DOI Bib PDF

Properties such as the absence of errors or bounds on mailbox sizes are hard to deduce statically for actor-based programs. This is because actor-based programs exhibit several sources of unboundedness, in addition to the non-determinism that is inherent to the concurrent execution of actors. We developed a static technique based on abstract interpretation to soundly reason in a finite amount of time about the possible executions of an actor-based program. We use our technique to statically verify the absence of errors in actor-based programs, and to compute upper bounds on the actors’ mailboxes. Sound abstraction of these mailboxes is crucial to the precision of any such technique. We provide several mailbox abstractions and categorize them according to the extent to which they preserve message ordering and multiplicity of messages in a mailbox. We formally prove the soundness of each mailbox abstraction, and empirically evaluate their precision and performance trade-offs on a corpus of benchmark programs. The results show that our technique can statically verify the absence of errors for more benchmark programs than the state-of-the-art analysis.
@inproceedings{Stivenart2017Mailbox, doi = {10.4230/LIPICS.ECOOP.2017.25}, url = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2017.25}, author = {Stiévenart, Quentin and Nicolay, Jens and De Meuter, Wolfgang and De Roover, Coen}, keywords = {static analysis, abstraction, abstract interpretation, actors, mailbox}, language = {en}, title = {Mailbox Abstractions for Static Analysis of Actor Programs}, booktitle = {31st European Conference on Object-Oriented Programming (ECOOP 2017)}, series = {LIPIcs}, volume = {74}, pages = {25:1-25:30}, publisher = {Schloss Dagstuhl – Leibniz-Zentrum für Informatik}, year = {2017}, copyright = {Creative Commons Attribution 3.0 Unported license} }
Static Taint Analysis of Event-driven Scheme Programs

Jonas De Bleser, Quentin Stiévenart, Jens Nicolay, and 1 more author

In Proceedings of the 10th European Lisp Symposium (ELS), Apr 2017

Abs Bib PDF

Event-driven programs consist of event listeners that can be registered dynamically with different types of events. The order in which these events are triggered is, however, non-deterministic. This combination of dynamicity and non-determinism renders reasoning about event-driven applications difficult. For example, it is possible that only a particular sequence of events causes certain program behavior to occur. However, manually determining the event sequence from all possibilities is not a feasible solution. Tool support is in order. We present a static analysis that computes a sound over-approximation of the behavior of an event-driven program. We use this analysis as the foundation for a tool that warns about potential leaks of sensitive information in event-driven Scheme programs. We innovate by presenting developers a regular expression that describes the sequence of events that must be triggered for the leak to occur. We assess precision, recall, and accuracy of the tool’s results on a set of benchmark programs that model the essence of security vulnerabilities found in the literature.
@inproceedings{DeBleser2017Static, title = {Static Taint Analysis of Event-driven Scheme Programs}, author = {{De Bleser}, Jonas and Sti{\'e}venart, Quentin and Nicolay, Jens and {De Roover}, Coen}, year = {2017}, month = apr, day = {4}, language = {English}, pages = {80--87}, booktitle = {Proceedings of the 10th European Lisp Symposium (ELS)}, publisher = {ACM}, url = {https://www.european-lisp-symposium.org/} }
Prevalence of Botched Code Integrations

Ward Muylaert and Coen De Roover

In 2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR), May 2017

Abs DOI Bib PDF

Integrating code from different sources can be an error-prone and effort-intensive process. While an integration may appear statically sound, unexpected errors may still surface at run time. The industry practice of continuous integration aims to detect these and other run-time errors through an extensive pipeline of successive tests. Using data from a continuous integration service, Travis CI, we look into the prevalence of integration errors. We find code integration causes failure less often than regular commits. Repairing is usually done the same day and takes less than ten lines of code, largely in the source code. These results indicate that applying proper practices mitigates many issues associated with code integration.
@inproceedings{Muylaert2017Prevalence, title = {Prevalence of Botched Code Integrations}, url = {http://dx.doi.org/10.1109/MSR.2017.40}, doi = {10.1109/msr.2017.40}, booktitle = {2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR)}, publisher = {IEEE}, author = {Muylaert, Ward and De Roover, Coen}, year = {2017}, month = may, pages = {503–506} }
Mining Change Histories for Unknown Systematic Edits

Tim Molderez, Reinout Stevens, and Coen De Roover

In 2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR), May 2017

Abs DOI Bib PDF

Software developers often need to repeat similar modifications in multiple different locations of a system’s source code. These repeated similar modifications, or systematic edits, can be both tedious and error-prone to perform manually. While there are tools that can be used to assist in automating systematic edits, it is not straightforward to find out where the occurrences of a systematic edit are located in an existing system. This knowledge is valuable to help decide whether refactoring is needed, or whether future occurrences of an existing systematic edit should be automated. In this paper, we tackle the problem of finding unknown systematic edits using a closed frequent itemset mining algorithm, operating on sets of distilled source code changes. This approach has been implemented for Java programs in a tool called SEM. To evaluate the tool’s precision and scalability, we have applied it to an industrial use case.
@inproceedings{Molderez2017Mining, title = {Mining Change Histories for Unknown Systematic Edits}, url = {http://dx.doi.org/10.1109/MSR.2017.12}, doi = {10.1109/msr.2017.12}, booktitle = {2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR)}, publisher = {IEEE}, author = {Molderez, Tim and Stevens, Reinout and De Roover, Coen}, year = {2017}, month = may, pages = {248–256} }

2016

Building a modular static analysis framework in Scala (tool paper)

Quentin Stiévenart, Jens Nicolay, Wolfgang De Meuter, and 1 more author

In Proceedings of the 2016 7th ACM SIGPLAN Symposium on Scala, Oct 2016

Abs DOI Bib PDF

We present SCALA-AM, a framework for implementing static analyses as systematically abstracted abstract machines. Analyses implemented on top of SCALA-AM separate operational semantics from machine abstraction concerns. This modularity facilitates varying the analyzed language and the applied abstraction method in an analysis. We describe the design of our framework and demonstrate its use in a static analysis for the DOT calculus. We conclude with a tour of the features of Scala through which SCALA-AM achieves its modularity.
@inproceedings{Stivenart2016Building, series = {SPLASH ’16}, title = {Building a modular static analysis framework in Scala (tool paper)}, url = {http://dx.doi.org/10.1145/2998392.3001579}, doi = {10.1145/2998392.3001579}, booktitle = {Proceedings of the 2016 7th ACM SIGPLAN Symposium on Scala}, publisher = {ACM}, author = {Stiévenart, Quentin and Nicolay, Jens and De Meuter, Wolfgang and De Roover, Coen}, year = {2016}, month = oct, pages = {105–109}, collection = {SPLASH ’16} }
Automated Generalization and Refinement of Code Templates with Ekeko/X

Tim Molderez and Coen De Roover

In Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER), 2016

Best Tool Paper Award Abs DOI Bib PDF

Best Tool Paper Award, SANER 2016.

Code templates are a convenient means to specify source code snippets of interest. However, despite a low learning curve, it may not always be evident to write templates that produce only the desired matches. A template may be too general and result in false positives, or too specific and produce false negatives. We assist the users of Ekeko/X, our template-based search and transformation tool for Java using a two-component approach: First, we present a suite of mutation operators to simplify editing templates. Some operators only modify a single component of a template, whereas others can automate high-level operations involving multiple components, such as abstracting away the declaration of a method and all calls to it using metavariables. Second, we introduce a genetic search algorithm that uses our suite of mutation operators and can recommend a sequence of changes to a template, such that it matches with a desired set of code snippets. The approach is evaluated by letting it infer a template that matches all instances of a design pattern, given one instance as a starting template.
@inproceedings{Molderez2016Automated, doi = {10.1109/saner.2016.19}, title = {Automated Generalization and Refinement of Code Templates with Ekeko/X}, keywords = {program search and transformation tools, source code templates, search-based software engineering, genetic algorithms}, author = {Molderez, Tim and {De Roover}, Coen}, year = {2016}, language = {English}, isbn = {978-1-5090-1855-0}, pages = {669--672}, booktitle = {Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER)}, publisher = {IEEE Computer Society Press} }
A Performant Scheme Interpreter in asm.js

Noah Van Es, Jens Nicolay, Quentin Stiévenart, and 2 more authors

In Proceedings of the 31st ACM Symposium on Applied Computing, Programming Languages Track (SAC 2016), 2016

Abs DOI Bib PDF

This paper presents the implementation of an efficient interpreter for a Scheme-like language using manually written asm.js code. The asm.js specification defines an optimizable subset of JavaScript which has already served well as a compilation target for web applications where performance is critical. However, its usage as a human-writable language that can be integrated into existing projects to improve performance has remained largely unexplored. We therefore apply this strategy to optimize the implementation of an interpreter. We also discuss the feasibility of this approach, as writing asm.js by hand is generally not its recommended use-case. We therefore present a macro system to solve the challenges we encounter. The resulting interpreter is compared to the original C implementation and its compiled equivalent in asm.js. This way, we evaluate whether manual integration with asm.js provides the necessary performance to bring larger applications and runtimes to the web.
@inproceedings{VanEs2016Performant, doi = {10.1145/2851613.2851748}, title = {A Performant Scheme Interpreter in asm.js}, keywords = {asm.js, JavaScript, interpreters, optimization, performance}, author = {{Van Es}, Noah and Nicolay, Jens and Sti{\'e}venart, Quentin and D'Hondt, Theo and {De Roover}, Coen}, year = {2016}, language = {English}, isbn = {978-1-4503-3739-7}, pages = {1944--1951}, booktitle = {Proceedings of the 31st ACM Symposium on Applied Computing, Programming Languages Track (SAC 2016)}, publisher = {ACM} }
Linvail: A General-Purpose Platform for Shadow Execution of JavaScript

Laurent Christophe, Wolfgang De Meuter, Elisa Gonzalez Boix, and 1 more author

In Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2016), Mar 2016

Abs DOI Bib PDF

We present Linvail, a novel instrumentation platform for developing dynamic analyses of JavaScript programs. Linvail is particularly well-suited to implementing shadow executions which involve tagging runtime values with analysis-specific data. In contrast to existing instrumentation platforms, Linvail is capable of tracking both tagged objects and tagged primitive values during their entire life-time in a behavior-preserving manner. To demonstrate the expressiveness of our platform, we present the implementation of several state-of-the-art analyses. Our experiments demonstrate that Linvail’s accuracy comes at the price of a performance overhead, but we believe that real-world applications will remain usable under analysis.
@inproceedings{Christophe2016Linvail, doi = {10.1109/saner.2016.91}, title = {Linvail: A General-Purpose Platform for Shadow Execution of JavaScript}, keywords = {Shadow Execution, Dynamic Analysis, JavaScript, Taint Analysis, Object Proxy, Reflection, Membrane Pattern, ECMAScript6}, author = {Christophe, Laurent and {De Meuter}, Wolfgang and {Gonzalez Boix}, Elisa and {De Roover}, Coen}, year = {2016}, month = mar, day = {18}, language = {English}, isbn = {978-1-5090-1855-0}, pages = {260--270}, booktitle = {Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2016)}, publisher = {IEEE CS} }
Search-Based Generalization and Refinement of Code Templates

Tim Molderez and Coen De Roover

In Search Based Software Engineering (SSBSE), 2016

Abs DOI Bib PDF

Several tools support code templates as a means to specify searches within a program’s source code. Despite their ubiquity, code templates can often prove difficult to specify, and may produce too many or too few match results. In this paper, we present a search-based approach to support developers in specifying templates. This approach uses a suite of mutation operators to recommend changes to a given template, such that it matches with a desired set of code snippets. We evaluate our approach on the problem of inferring a code template that matches all instances of a design pattern, given one instance as a starting template.
@incollection{Molderez2016Search, title = {Search-Based Generalization and Refinement of Code Templates}, isbn = {9783319471068}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-319-47106-8_13}, doi = {10.1007/978-3-319-47106-8_13}, booktitle = {Search Based Software Engineering (SSBSE)}, publisher = {Springer International Publishing}, author = {Molderez, Tim and De Roover, Coen}, year = {2016}, pages = {192–208} }
Dependence-driven delimited CPS transformation for JavaScript

Laure Philips, Joeri De Koster, Wolfgang De Meuter, and 1 more author

In Proceedings of the 2016 ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE), Oct 2016

Abs DOI Bib PDF

In today’s web applications asynchronous requests to remote services using callbacks or futures are omnipresent. The continuation of such a non-blocking task is represented as a callback function that will later be called with the result of the request. This style of programming where the remainder of a computation is captured in a continuation function is called continuation-passing style (CPS). This style of programming can quickly lead to a phenomenon called “callback hell”, which has a negative impact on the maintainability of applications that employ this style. Several alter- natives to callbacks are therefore gaining traction within the web domain. For example, there are a number of frameworks that rely on automatically transforming code, written without callbacks in a direct sequential style, into the continuation-passing style. How- ever, these frameworks often employ a conservative approach in which each function call is transformed into CPS. Even when they do a selective transformation they will often encapsulate the entire remainder of the computation in the continuation. This conservative approach can sequentialise requests that could otherwise be run in parallel. So-called delimited continuations can remedy, but require special marks that have to be manually inserted in the code for marking the beginning and end of the continuation. In this paper we propose an alternative strategy in which we apply a delimited CPS transformation that operates on a Program Dependence Graph instead to find the limits of each continuation. We implement this strategy in JavaScript and demonstrate its applicability to various web programming scenarios.
@inproceedings{Philips2016Dependence, series = {GPCE ’16}, title = {Dependence-driven delimited CPS transformation for JavaScript}, url = {http://dx.doi.org/10.1145/2993236.2993243}, doi = {10.1145/2993236.2993243}, booktitle = {Proceedings of the 2016 ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE)}, publisher = {ACM}, author = {Philips, Laure and De Koster, Joeri and De Meuter, Wolfgang and De Roover, Coen}, year = {2016}, month = oct, pages = {59–69}, collection = {GPCE ’16} }
Scala-AM: A Modular Static Analysis Framework

Quentin Stiévenart, Maarten Vandercammen, Wolfgang De Meuter, and 1 more author

In 16th IEEE International Working Conference on Source Code Analysis and Manipulation, SCAM 2016 (SCAM), 2016

Abs DOI Bib PDF

We present Scala-AM, a modular framework for static analysis based on systematic abstraction of abstract machines. Scala-AM achieves modularity by separating operational semantics, abstract values and machine abstraction concerns via actions, thus enabling language designers, static analysis developers and machine abstraction experts to combine their efforts. This modularity enables us to support semantics for multiple languages, and to include multiple machine abstractions in our framework. Different operational semantics and machine abstractions can then be combined with minimal effort. We evaluate our framework by demonstrating how it enables implementing machine abstractions independently of the operational semantics, and by instantiating the framework for a static taint analysis of Scheme.
@inproceedings{Stievenart2016Scala, doi = {10.1109/scam.2016.14}, title = {Scala-AM: A Modular Static Analysis Framework}, keywords = {abstract interpretation, static analysis, framework}, author = {Sti{\'e}venart, Quentin and Vandercammen, Maarten and {De Meuter}, Wolfgang and {De Roover}, Coen}, year = {2016}, language = {English}, pages = {85--90}, booktitle = {16th IEEE International Working Conference on Source Code Analysis and Manipulation, SCAM 2016 (SCAM)}, url = {http://www.ieee-scam.org/2016/} }

2015

Detecting Function Purity in JavaScript

Jens Nicolay, Carlos Francisco Noguera Garcia, Coen De Roover, and 1 more author

In Proceedings of the 15th IEEE Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2015

Best Paper Award Abs DOI Bib PDF

Best Paper Award, SCAM 2015.

We present an approach to detect function purity in JavaScript. A function is pure if none of its applications cause observable side-effects. The approach is based on a pushdown flow analysis that besides traditional control and value flow also keeps track of write effects. To increase the precision of our purity analysis, we combine it with an intraprocedural analysis to determine freshness of variables and object references. We formalize the core aspects of our analysis, and discuss our implementation used to analyze several common JavaScript benchmarks. Experiments show that our technique is capable of detecting function purity, even in the presence of higher-order functions, dynamic property expressions, and prototypal inheritance.
@inproceedings{Nicolay2015Detecting, doi = {10.1109/scam.2015.7335406}, title = {Detecting Function Purity in JavaScript}, keywords = {static analysis, abstract interpretation, effects, JavaScript}, author = {Nicolay, Jens and {Noguera Garcia}, {Carlos Francisco} and {De Roover}, Coen and {De Meuter}, Wolfgang}, year = {2015}, month = sep, language = {English}, isbn = {9781467375306}, pages = {101--110}, booktitle = {Proceedings of the 15th IEEE Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE} }
Detecting Concurrency Bugs in Higher-Order Programs through Abstract Interpretation

Quentin Stievenart, Jens Nicolay, Wolfgang De Meuter, and 1 more author

In Proceedings of the 17th International Symposium on Principles and Practice of Declarative Programming (PPDP), 2015

Abs DOI Bib PDF

Manually detecting bugs in concurrent programs is hard due to the myriad of thread interleavings that needs to be accounted for. Higher-order programming features only exacerbate this difficulty. The need for tool support therefore increases as these features become more widespread. We investigate the \PCESK abstract machine as the foundation for tool support for detecting concurrency bugs. This abstract interpreter analyzes multi-threaded, higher-order programs with shared-store concurrency and a compare-and-swap synchronization primitive. In this paper, we evaluate two different approaches to reduce the size of the state space explored by the abstract interpreter. First, we integrate abstract garbage collection into the abstract interpreter, and we observe that it does not reduce the state space as expected. We then evaluate the impact of adding first-class support for locks on the machine’s client analyses. To this end, we compare a cas-based and a lock-based formulation of race condition and deadlock detection analyses. We show that adding first-class support for locks not only significantly reduces the number of abstract program states that need to be explored, but also simplifies formulating the client analyses.
@inproceedings{Stievenart2015Detecting, doi = {10.1145/2790449.2790530}, title = {Detecting Concurrency Bugs in Higher-Order Programs through Abstract Interpretation}, author = {Stievenart, Quentin and Nicolay, Jens and {De Meuter}, Wolfgang and {De Roover}, Coen}, year = {2015}, language = {English}, pages = {232--243}, booktitle = {Proceedings of the 17th International Symposium on Principles and Practice of Declarative Programming (PPDP)}, publisher = {ACM SIGPLAN} }

2014

Towards Tierless Web Development without Tierless Languages

Laure Philips, Coen De Roover, Tom Van Cutsem, and 1 more author

In Onward! ’14 (SPLASH/OnWard!), Oct 2014

Abs DOI Bib PDF

Tierless programming languages enable developing the typical server, client and database tiers of a web application as a single mono-linguistic program. This development style is in stark contrast to the current practice which requires combining multiple technologies and programming languages. A myriad of tierless programming languages has already been proposed, often featuring a JavaScript-like syntax. Instead of introducing yet another, we advocate that it should be possible to develop tierless web applications in existing general- purpose languages. This not only reduces the complexity that developers are exposed to, but also precludes the need for new development tools. We concretize this novel approach to tierless programming by discussing requirements on its future instantiations. We explore the design space of the program analysis for determining and the program trans- formation for realizing the tier split respectively. The former corresponds to new adaptations of an old familiar, program slicing, for tier splitting. The latter includes several strategies for handling cross-tier function calls and data accesses. Using a prototype instantiation for JavaScript, we demonstrate the feasibility of our approach on an example web application. We conclude with a discussion of open questions and challenges for future research.
@inproceedings{Philips2014Towards, doi = {10.1145/2661136.2661146}, title = {Towards Tierless Web Development without Tierless Languages}, keywords = {Tier splitting, Program slicing, Tierless programming, JavaScript}, author = {Philips, Laure and {De Roover}, Coen and {Van Cutsem}, Tom and {De Meuter}, Wolfgang}, year = {2014}, month = oct, day = {24}, language = {English}, isbn = {978-1-4503-3210-1}, series = {Proceedings of the ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software Proceedings}, publisher = {ACM}, booktitle = {Onward! '14 (SPLASH/OnWard!)}, url = {http://2014.splashcon.org/home} }
Prevalence and Maintenance of Automated Functional Tests for Web Applications

Laurent Christophe, Reinout Stevens, Coen De Roover, and 1 more author

In Proceedings of the 30th International Conference on Software Maintenance and Evolution (ICSMe), Oct 2014

Abs DOI Bib PDF

Functional testing requires executing particular sequences of user actions. Test automation tools enable scripting user actions such that they can be repeated more easily. SELENIUM, for instance, enables testing web applications through scripts that interact with a web browser and assert properties about its observable state. However, little is known about how common such tests are in practice. We therefore present a cross-sectional quantitative study of the prevalence of SELENIUM-based tests among open-source web applications, and of the extent to which such tests are used within individual applications. Automating functional tests also brings about the problem of maintaining test scripts. As the system under test evolves, its test scripts are bound to break. Even less is known about the way test scripts change over time. We therefore also present a longitudinal quantitative study of whether and for how long test scripts are maintained, as well as a longitudinal qualitative study of the kind of changes they undergo. To the former’s end, we propose two new metrics based on whether a commit to the application’s version repository touches a test file. To the latter’s end, we propose to categorize the changes within each commit based on the elements of the test upon which they operate. As such, we are able to identify the elements of a test that are most prone to change.
@inproceedings{Christophe2014Prevalence, doi = {10.1109/icsme.2014.36}, title = {Prevalence and Maintenance of Automated Functional Tests for Web Applications}, keywords = {Functional Testing, Selenium, Test Maintenance, empirical study, mining software repositories}, author = {Christophe, Laurent and Stevens, Reinout and {De Roover}, Coen and {De Meuter}, Wolfgang}, year = {2014}, month = oct, day = {1}, language = {English}, isbn = {978-1-4799-6146-7}, series = {Proceedings of the 30th International Conference on Software Maintenance and Evolution (ICSMe14)}, pages = {141--150}, booktitle = {Proceedings of the 30th International Conference on Software Maintenance and Evolution (ICSMe)} }
Identifying Source Code Reuse across Repositories using LCS-based Source Code Similarity

Naohiro Kawamitsu, Takashi Ishio, Tetsuya Kanda, and 3 more authors

In Proceedings of 14th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM), 2014

Abs DOI Bib PDF

Developers often reuse source files developed for another project. In order to update a reused file to a newer version released by the original project, developers have to track which revision of a file was reused and how its content was modified. However, such tracking is tedious for developers. Many projects keep older versions of files whose bugs are already fixed in the original project. In this paper, we propose a technique to automatically identify source code reuse relationships between two repositories. Using a similarity metric based on longest common subsequence, we identify pairs of similar revisions of files across the repositories. To evaluate our approach, we have analyzed eight project pairs of open source software projects and compared the result with the recorded information in the repositories. As a result, we have identified 1394 file revisions as instances of source code reuse. While 75.3% of the instances are recorded in the repositories, 20.1% of the instances are unrecorded but recovered by our approach.
@inproceedings{Kawamitsu2014Identifying, doi = {10.1109/scam.2014.17}, title = {Identifying Source Code Reuse across Repositories using LCS-based Source Code Similarity}, keywords = {software reuse, code similarity, origin analysis}, author = {Kawamitsu, Naohiro and Ishio, Takashi and Kanda, Tetsuya and Kula, {Raula Gaikovina} and {De Roover}, Coen and Inoue, Katsuro}, year = {2014}, language = {English}, isbn = {978-1-4799-6148-1}, series = {Proceedings of 14th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM14)}, pages = {305--314}, booktitle = {Proceedings of 14th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM)} }
Querying the History of Software Projects using QwalKeko

Reinout Stevens and Coen De Roover

In Proceedings of the IEEE International Conference on Software Maintenance and Evolution (ICSME 2014), 2014

Abs DOI Bib PDF

We present the QWALKEKO meta-programming library for Clojure that enables querying the history of versioned software projects in a declarative manner. Unique to this library is its support for regular path expressions within history queries. Regular path expressions are akin to regular expressions, except that they match a sequence of successive snapshots of a software project along which user-specified logic conditions must hold. Such logic conditions can concern the source code within a snapshot, versioning information associated with the snapshot, as well as patterns of source code changes with respect to other snapshots. We have successfully used the resulting multi-faceted queries to detect refactorings in project histories. In this paper, we discuss how applicative logic meta-programming enabled combining the heterogenous components of QWALKEKO into a uniform whole. We focus on the applicative logic interface to a new implementation of a well-known change distilling algorithm. We use the problem of detecting and categorizing changes made to SELENIUM-based test scripts for illustration purposes.
@inproceedings{Stevens2014Querying, doi = {10.1109/icsme.2014.101}, title = {Querying the History of Software Projects using QwalKeko}, keywords = {history querying tool, program querying tool, mining software repositories}, author = {Stevens, Reinout and {De Roover}, Coen}, year = {2014}, language = {English}, isbn = {978-1-4799-6146-7}, series = {Proceedings of the IEEE International Conference on Software Maintenance and Evolution (ICSME 2014)}, publisher = {IEEE}, pages = {585--588}, booktitle = {Proceedings of the IEEE International Conference on Software Maintenance and Evolution (ICSME 2014)} }
The Ekeko/X Program Transformation Tool

Coen De Roover and Katsuro Inoue

In Proceedings of 14th IEEE International Working Conference on Source Code Analysis and Manipulation, Tool Demo Track (SCAM 2014), 2014

Abs DOI Bib PDF

Developers often need to perform repetitive changes to source code. For instance, to repair several instances of a bug or to update all clients of a library to a newer version. Manually performing such changes is laborious and error-prone. Program transformation tools enable automating changes, but specifying changes as a program transformation requires significant expertise. Code templates are often touted as a remedy, yet have never been endorsed wholeheartedly. Their use is mostly limited to expressing the syntactic characteristics of the intended change subjects. Less familiar means have to be resorted to for expressing their structural, control flow, and data flow characteristics. In this tool paper, we introduce a decidedly template-driven program transformation tool called Ekeko/X. Its specifications feature templates for specifying all of the aforementioned characteristics of its subjects. To this end, developers can associate different directives with individual components of a template. Each matching directive imposes particular constraints on the matches for the component it is associated with. Rewriting directives, on the other hand, determine how each match should be changed. We develop Ekeko/X from the ground up, starting from its applicative logic meta-programming foundation. We highlight the key choices in this implementation and demonstrate its use through two example program transformations.
@inproceedings{DeRoover2014Ekeko, doi = {10.1109/scam.2014.32}, title = {The Ekeko/X Program Transformation Tool}, keywords = {program transformation, code template, program analysis, refactoring}, author = {{De Roover}, Coen and Inoue, Katsuro}, year = {2014}, language = {English}, isbn = {978-1-4799-6148-1}, series = {Proceedings of 14th IEEE International Working Conference on Source Code Analysis and Manipulation, Tool Demo Track (SCAM 2014)}, pages = {53--58}, booktitle = {Proceedings of 14th IEEE International Working Conference on Source Code Analysis and Manipulation, Tool Demo Track (SCAM 2014)} }
Building Development Tools Interactively using the Ekeko Meta-Programming Library

Coen De Roover and Reinout Stevens

In Proceedings of the IEEE CSMR-WCRE 2014 Software Evolution Week, Tool Demo Track (CSMR-WCRE), 2014

Abs DOI Bib PDF

Ekeko is a Clojure library for applicative logic meta-programming against an Eclipse workspace. Ekeko has been applied successfully to answering program queries (e.g., "does this bug pattern occur in my code?”), to analyzing project corpora (e.g., "how often does this API usage pattern occur in this corpus?”), and to transforming programs (e.g., "change occurrences of this pattern as follows”) in a declarative manner. These applications rely on a seamless embedding of logic queries in applicative expressions. While the former identify source code of interest, the latter associate error markers with, compute statistics about, or rewrite the identified source code snippets. In this paper, we detail the logic and applicative aspects of the Ekeko library. We also highlight key choices in their implementation. In particular, we demonstrate how a causal connection with the Eclipse infrastructure enables building development tools interactively on the Clojure read-eval-print loop.
@inproceedings{DeRoover2014Building, doi = {10.1109/csmr-wcre.2014.6747211}, title = {Building Development Tools Interactively using the Ekeko Meta-Programming Library}, keywords = {meta-programming, applicative programming, logic programming, tool building, software engineering, program analysis, program transformation}, author = {{De Roover}, Coen and Stevens, Reinout}, year = {2014}, language = {English}, isbn = {978-1-4799-3752-3}, series = {Proceedings of the IEEE CSMR-WCRE 2014 Software Evolution Week (CSMR-WCRE14), Tool Demo Track}, publisher = {IEEE}, booktitle = {Proceedings of the IEEE CSMR-WCRE 2014 Software Evolution Week, Tool Demo Track (CSMR-WCRE)} }
Visualizing the Evolution of Systems and their Library Dependencies

Raula Gaikovina Kula, Coen De Roover, Daniel German, and 2 more authors

In Proceedings of the 2nd IEEE Working Conference on Software Visualization (VISSOFT), 2014

Most Influential Paper Award Abs DOI Bib PDF

Most Influential Paper Award, VISSOFT 2024.

System maintainers face several challenges stemming from a system and its library dependencies evolving separately. Novice maintainers may lack the historical knowledge required to efficiently manage an inherited system. While some libraries are regularly updated, some systems keep a dependency on older versions. On the other hand, maintainers may be unaware that other systems have settled on a different version of a library. In this paper, we visualize how the dependency relation between a system and its dependencies evolves from two perspectives. Our system-centric dependency plots (SDP) visualize the successive library versions a system depends on over time. The radial layout and heat-map metaphor provide visual clues about the change in dependencies along the system’s release history. From this perspective, maintainers can navigate to a library-centric dependants diffusion plot (LDP). The LDP is a time-series visualization that shows the diffusion of users across the different versions of a library. We demonstrate on real-world systems how maintainers can benefit from our visualizations through four case scenarios.
@inproceedings{Kula2014Visualizing, doi = {10.1109/vissoft.2014.29}, title = {Visualizing the Evolution of Systems and their Library Dependencies}, keywords = {software visualization, software libraries, software evolution}, author = {Kula, {Raula Gaikovina} and {De Roover}, Coen and German, Daniel and Ishio, Takashi and Inoue, Katsuro}, year = {2014}, language = {English}, isbn = {978-1-4799-6150-4}, pages = {127--136}, booktitle = {Proceedings of the 2nd IEEE Working Conference on Software Visualization (VISSOFT)} }

2013

Aspectual Source Code Analysis with GASR

Johan Fabry, Coen De Roover, and Viviane Jonckers

In Proceedings of the 13th International Working Conference on Source Code Analysis and Manipulation (SCAM 2013), 2013

Abs DOI Bib PDF

To be able to modularize crosscutting concerns, aspects introduce new programming language features, often in a new language, with a specific syntax. These new features lead to new needs for source code analysis tools, resulting in the requirement for a general-purpose aspectual source code analysis tool. Ignoring this requirement has led to a nontrivial duplication of effort in the aspect-oriented software development community. This is because all code analysis efforts that we are aware of have either built ad-hoc analysis tools or were performed manually. In this paper we present GASR: a source code analysis tool in the tradition of logic program querying that reasons over AspectJ source code. By hooking into the IDE plugins for AspectJ, GASR provides a library of predicates that can be used to query aspectual source code. We demonstrate the use of GASR by automating the recognition of a number of previously identified aspectual source code assumptions. We then detect assumption instances on two well-known case studies that were manually investigated in the earlier work. In addition to finding the already known aspect assumptions, GASR encounters assumption instances that were overlooked before.
@inproceedings{Fabry2013Aspectual, doi = {10.1109/scam.2013.6648184}, title = {Aspectual Source Code Analysis with GASR}, keywords = {Aspect Oriented Programming, Logic Program Querying, Aspectual Assumptions}, author = {Fabry, Johan and {De Roover}, Coen and Jonckers, Viviane}, year = {2013}, language = {English}, isbn = {978-1-4673-5739-5}, pages = {53--62}, booktitle = {Proceedings of the 13th International Working Conference on Source Code Analysis and Manipulation (SCAM 2013)}, publisher = {IEEE} }
Determining dynamic coupling in JavaScript using object type inference

Jens Nicolay, Carlos Noguera, Coen De Roover, and 1 more author

In 2013 IEEE 13th International Working Conference on Source Code Analysis and Manipulation (SCAM), Sep 2013

Abs DOI Bib PDF

Coupling in an object-oriented context is often deﬁned in terms of access to instance variables and methods of other classes. JavaScript, however, lacks static type informa- tion and classes, and instead features a ﬂexible object system with prototypal inheritance. In order to determine coupling in JavaScript, we infer object types based on abstract interpretation of a program. Type inference depends on both structure and behavior of objects, and common patterns for expressing classes and modules are supported. We approximate a set of accessed types per function, and classify every access as either local or foreign. Examples demonstrate that our object type inference, together with some additional heuristics concerning property access, enable determining coupling in JavaScript in a meaningful way.
@inproceedings{Nicolay2013Determining, title = {Determining dynamic coupling in JavaScript using object type inference}, url = {http://dx.doi.org/10.1109/SCAM.2013.6648193}, doi = {10.1109/scam.2013.6648193}, booktitle = {2013 IEEE 13th International Working Conference on Source Code Analysis and Manipulation (SCAM)}, publisher = {IEEE}, author = {Nicolay, Jens and Noguera, Carlos and De Roover, Coen and De Meuter, Wolfgang}, year = {2013}, month = sep, pages = {126–135} }
A History Querying Tool and its Application to Detect Multi-version Refactorings

Reinout Stevens, Coen De Roover, Carlos Francisco Noguera Garcia, and 1 more author

In Proceedings of the 17th European Conference on Software Maintenance and Reengineering, Early Research Achievements Track (CSMR 2013), 2013

Abs DOI Bib PDF

Version Control Systems (VCS) have become indispensable in developing software. In order to provide support for change management, they track the history of software projects. Tool builders can exploit this latent historical information to provide insights in the evolution of the project. For example, the information needed to identify when and where a particular refactoring was applied is implicitly present in the VCS. However, tool support for eliciting this information is lacking. So far, no general-purpose history querying tool capable of answering a wide variety of questions about the evolution of software exists. Therefore, we generalize the idea of a program querying tool to a history querying tool. A program querying tool reifies the program’s code into a knowledge base, from which it retrieves elements that exhibit characteristics specified through a user-provided program query. Our history querying tool, QwalKeko, enables specifying the evolution of source code characteristics across multiple versions of Java projects versioned in Git. We apply QwalKeko to the problem of detecting refactorings, specified as the code changes induced by each refactoring. These specifications stem from the literature, but are limited to changes between two successive versions. We demonstrate the expressiveness of our tool by generalizing the specifications such that refactorings can span multiple versions.
@inproceedings{Stevens2013History, doi = {10.1109/csmr.2013.44}, title = {A History Querying Tool and its Application to Detect Multi-version Refactorings}, keywords = {program comprehension, history querying, program querying, refactoring, version repositories}, author = {Stevens, Reinout and {De Roover}, Coen and {Noguera Garcia}, {Carlos Francisco} and Jonckers, Viviane}, year = {2013}, language = {English}, isbn = {978-1-4673-5833-0}, pages = {335--338}, booktitle = {Proceedings of the 17th European Conference on Software Maintenance and Reengineering, Early Research Achievements Track (CSMR 2013)}, publisher = {IEEE} }
Multi-dimensional Exploration of API Usage

Coen De Roover, Ralf Lämmel, and Ekaterina Pek

In Proceedings of the 21st IEEE International Conference on Program Comprehension (ICPC), 2013

Abs DOI Bib PDF

This paper is concerned with understanding API usage in a systematic, explorative manner for the benefit of both API developers and API users. There exist complementary, less explorative methods, e.g., based on code search, code completion, or API documentation. In contrast, our approach is highly interactive and can be seen as an extension of what IDEs readily provide today. Exploration is based on multiple dimensions: i) the hierarchically organized scopes of projects and APIs; ii) metrics of API usage (e.g., number of project classes extending API classes); iii) metadata for APIs; iv) project- versus API-centric views. We also provide the QUAATLAS corpus of Java projects which enhances the existing QUALITAS corpus to enable API- usage analysis. We implemented the exploration approach in an open-source, IDE-like, Web-enabled tool EXAPUS.
@inproceedings{DeRoover2013Multi, doi = {10.1109/icpc.2013.6613843}, title = {Multi-dimensional Exploration of API Usage}, keywords = {API usage, code exploration, program comprehension, reverse engineering}, author = {{De Roover}, Coen and L{\"a}mmel, Ralf and Pek, Ekaterina}, year = {2013}, language = {English}, isbn = { 978-1-4673-3092-3}, series = {Proceedings of the 21st IEEE International Conference on Program Comprehension (ICPC13)}, publisher = {IEEE}, pages = {152--161}, booktitle = {Proceedings of the 21st IEEE International Conference on Program Comprehension (ICPC)} }

2012

Constructing Customized Interpreters from Reusable Evaluators using Game

Stijn Timbermont, Coen De Roover, and Theo D’Hondt

In Proceedings of the 11th International Conference on Software Composition (SC), 2012

Best Student Paper Award Abs DOI Bib PDF

Best Student Paper Award, SC 2012.

Separation of concerns is difficult to achieve in the implementation of a programming language interpreter. We argue that evaluator concerns (i.e., those implementing the operational semantics of the language) are, in particular, difficult to separate from the runtime concerns (e.g., memory and stack management) that support them. This precludes the former from being reused and limits variability in the latter. In this paper, we present the Game environment for composing customized interpreters from a reusable evaluator and different variants of its supporting runtime. To this end, Game offers a language for specifying the evaluator according to the generic programming methodology. Through a transformation into defunctionalized monadic style, the Game toolchain generates a generic abstract machine in which the sequencing of low-level interpretational steps is parameterized. Given a suitable instantiation of these parameters for a particular runtime, the toolchain is able to inject the runtime into the generic abstract machine such that a complete interpreter is generated. To validate our approach, we port the prototypical Scheme evaluator to Game and compose the resulting generic abstract machine with several runtimes that vary in their automatic memory management as well as their stack discipline.
@inproceedings{Timbermont2012Constructing, doi = {10.1007/978-3-642-30564-1_7}, title = {Constructing Customized Interpreters from Reusable Evaluators using Game}, keywords = {generic programming, code generation, language interpreters, monads}, author = {Timbermont, Stijn and {De Roover}, Coen and D'Hondt, Theo}, year = {2012}, language = {English}, isbn = {978-3-642-30563-4}, volume = {7306}, series = {Lecture notes in Computer Science}, pages = {97--113}, booktitle = {Proceedings of the 11th International Conference on Software Composition (SC)} }
Refactoring in the Presence of Annotations

Carlos Francisco Noguera Garcia, Andy Kellens, Coen De Roover, and 1 more author

In 28th International Conference on Software Maintenance (ICSM), Sep 2012

Abs DOI Bib PDF

Current-day programming languages include constructs to embed meta-data in a program’s source code in the form of annotations. More than mere documentation, these annotations are used in modern frameworks to map source- level entities to domain-specific ones. A common example being the Hibernate Object-Relational Mapping framework that relies on annotations to declare persistence configurations. While the presence of annotations extends the base semantics of the language, it also imposes restrictions on the annotated program. In this paper we consider the manner in which annotations affect automated refactorings, and in particular how they break the behavior preservation of these refactorings. As refactorings, during their condition checking phase, ignore the annotation’s restrictions they can no longer guarantee the preservation of the domain-specific mappings. To address this problem, we propose to make the restrictions of the annotations explicit, and use them to steer the refactoring process. A prototype extension of the Eclipse IDE’s refactoring engine is used to demonstrate our approach on three annotation libraries: Java Persistence API, AspectJ5 and Simple XML serialization.
@inproceedings{NogueraGarcia2012Refactoring, doi = {10.1109/icsm.2012.6405291}, title = {Refactoring in the Presence of Annotations}, keywords = {refactoring, annotations, tool support}, author = {{Noguera Garcia}, {Carlos Francisco} and Kellens, Andy and {De Roover}, Coen and Jonckers, Viviane}, year = {2012}, month = sep, day = {1}, language = {English}, isbn = {978-1-4673-2312-3}, series = {International Conference on Software Maintenance (ICSM)}, publisher = {IEEE}, pages = {337--346}, booktitle = {28th International Conference on Software Maintenance (ICSM)} }
Code Querying by UML

Carlos Francisco Noguera Garcia, Coen De Roover, Andy Kellens, and 1 more author

In 20th International Conference on Program Comprehension (ICPC), Jun 2012

Abs DOI Bib PDF

The need to identify source code that exhibits particular characteristics is essential to program comprehension. In this paper we introduce ARABICA, a tool for querying Java code using UML class and sequence diagrams. Our use of UML diagrams avoids the need for developers to familiarize themselves with yet another language. In contrast to tools that rely on dedicated query languages, ARABICA encodes querying semantics in a dedicated, minimal UML profile. Stereotyped class and sequence diagrams, characterizing structural and behavioral properties respectively, are translated into logic program queries. Using examples from the JHotDraw framework, we illustrate the utility of ARABICA in validating design invariants, finding design pattern implementations and exploring extension points. We present a pre/post-test quasi experiment as a preliminary assessment of our approach.
@inproceedings{NogueraGarcia2012Code, doi = {10.1109/icpc.2012.6240492}, title = {Code Querying by UML}, keywords = {program querying, UML}, author = {{Noguera Garcia}, {Carlos Francisco} and {De Roover}, Coen and Kellens, Andy and Jonckers, Viviane}, year = {2012}, month = jun, day = {10}, language = {English}, isbn = {978-1-4673-1216-5}, series = {International Conference on Program Comprehension (ICPC)}, publisher = {IEEE}, pages = {229--238}, booktitle = {20th International Conference on Program Comprehension (ICPC)} }
Interruptible Context-dependent Executions: A Fresh Look at Programming Context-aware Applications.

Engineer Bainomugisha, Jorge Antonio Vallejos Vargas, Coen De Roover, and 2 more authors

In Onward! ’12: Proceedings of the ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software Proceedings (SPLASH/OnWard!), Oct 2012

Abs Bib PDF

Context-aware applications provide end-users with enhanced experiences by continuously sensing their environment and adapting their behaviour to match the current context of use. However, developing true context-aware applications remains notoriously difficult due to the unpredictable nature of context changes. A context change may occur at any moment during a procedure execution, which may require an ongoing execution to be promptly interrupted in order to prevent the procedure from running in a wrong context. Currently, developers have to manually constrain a procedure execution to a particular context and take care of saving and restoring the execution state between context changes. Such manual approaches are error-prone and may lead to incorrect application behaviour. This paper presents a novel programming language model called interruptible context-dependent executions, where a procedure execution is always constrained to happen only under a specified context. In this model, a procedure execution can be seamlessly interrupted or resumed depending on the context. Additionally, the procedure execution state is automatically preserved between interruptions. We present the Flute language that supports interruptible context-dependent executions.
@inproceedings{Bainomugisha2012Interruptible, title = {Interruptible Context-dependent Executions: A Fresh Look at Programming Context-aware Applications.}, keywords = {Context-aware applications, interruptible context-dependent executions, reactive dispatching, prompt adaptations}, author = {Bainomugisha, Engineer and {Vallejos Vargas}, {Jorge Antonio} and {De Roover}, Coen and {Lombide Carreton}, Andoni and {De Meuter}, Wolfgang}, year = {2012}, month = oct, day = {19}, language = {English}, isbn = {978-1-4503-1562-3 }, booktitle = {Onward! '12: Proceedings of the ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software Proceedings (SPLASH/OnWard!)}, publisher = {ACM} }

2011

Automatic Parallelization of Side-Effecting Higher-Order Scheme Programs.

Jens Nicolay, Coen De Roover, Wolfgang De Meuter, and 1 more author

In Proceedings of the 11th International Working Conference on Source Code Analysis and Manipulation (SCAM 2011), 2011

Abs DOI Bib PDF

The multi-core revolution heralds a challenging era for software maintainers. Manually parallelizing large sequential code bases is often infeasible. In this paper, we present a program transformation that automatically parallelizes real-life Scheme programs. The transformation has to be instantiated with an interprocedural dependence analysis that exposes parallelization opportunities in a sequential program. To this end, we extended a state-of-the art analysis that copes with higher-order procedures and side effects. Our parallelizing transformation exploits all opportunities for parallelization that are exposed by the dependence analysis. Experiments demonstrate that this brute-force approach realizes scalable speedups in certain benchmarks, while others would benefit from a more selective parallelization.
@inproceedings{Nicolay2011Automatic, doi = {10.1109/scam.2011.13}, title = {Automatic Parallelization of Side-Effecting Higher-Order Scheme Programs.}, keywords = {parallelization, static analysis, program transformation}, author = {Nicolay, Jens and {De Roover}, Coen and {De Meuter}, Wolfgang and Jonckers, Viviane}, year = {2011}, language = {English}, isbn = {9781457709326}, pages = {185--194}, booktitle = {Proceedings of the 11th International Working Conference on Source Code Analysis and Manipulation (SCAM 2011)} }
A Logic Meta-Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs

Coen De Roover

In Proceedings of the 27th IEEE International Conference on Software Maintenance (ICSM 2011), 2011

Abs DOI Bib PDF

This paper summarizes the doctoral dissertation in which we introduced an example-driven approach to pattern detection. This approach enables specifying pattern characteristics in a familiar language: through a code excerpt that corresponds to their prototypical implementation. Such excerpts are matched against the program under investigation according to various matching strategies that vary in leniency. Each match is quantified by the extent to which it exhibits the exemplified characteristics. The smaller this extent, the more likely the match is a false positive –thus establishing a ranking which facilitates assessing a large amount of matches. Unique to the matching process is that it incorporates whole-program analyses in its comparison of individual program elements. This way, we are able to recall implicit implementation variants (i.e., those implied by the semantics of the programming language) of a pattern of which only the prototypical implementation has been exemplified.
@inproceedings{DeRoover2011Logic, doi = {10.1109/icsm.2011.6080830}, title = {A Logic Meta-Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs}, keywords = {logic meta programming, pattern detection, program querying, static analysis}, author = {{De Roover}, Coen}, year = {2011}, language = {English}, isbn = {978-1-4577-0663-9}, series = {Proceedings of the 27th IEEE International Conference on Software Maintenance (ICSM 2011)}, booktitle = {Proceedings of the 27th IEEE International Conference on Software Maintenance (ICSM 2011)} }
Language Support for Programming Interactions among Wireless Sensor Network Nodes

Coen De Roover, Christophe Scholliers, Wouter Amerijckx, and 2 more authors

In Proceedings of the 5th International Symposium on Ubiquitous Computing and Ambient Intelligence (UCAmI 2011), 2011

Abs Bib PDF

An emerging breed of wireless sensor network applications tasks nodes not only with sensing, but also with reacting to sensor readings. Event-based middleware lends itself to implementing such applications. It offers developers fine-grained control over how an individual node interacts with the other nodes of the network. However, this control comes at the cost of event handlers which lack composability and violate software engineering principles such as separation of concerns. In this paper, we present CrimeSPOT as a domain-specific language for programing WSN applications on top of event-driven middleware. Its node-centric features enable programming a node’s interactions through declarative rules rather than event handlers. Its network-centric features support reusing code within and among WSN applications. Unique to CrimeSPOT is its support for associating application-specific semantics with events that carry sensor readings. These preclude transposing existing approaches that address the shortcomings of event-based middleware to the domain of wireless sensor networks.
@inproceedings{DeRoover2011Language, title = {Language Support for Programming Interactions among Wireless Sensor Network Nodes}, keywords = {wireless sensor networks, distributed programming, declarative programming}, author = {{De Roover}, Coen and Scholliers, Christophe and Amerijckx, Wouter and D'Hondt, Theo and {De Meuter}, Wolfgang}, year = {2011}, language = {English}, isbn = {978-84-694-9677-0}, series = {Proceedings of the 5th International Symposium on Ubiquitous Computing and Ambient Intelligence (UCAmI 2011)}, booktitle = {Proceedings of the 5th International Symposium on Ubiquitous Computing and Ambient Intelligence (UCAmI 2011)} }
The SOUL Tool Suite for Querying Programs in Symbiosis with Eclipse

Coen De Roover, Carlos Francisco Noguera Garcia, Andy Kellens, and 1 more author

In International Conference on the Principles and Practice of Programming in Java (PPPJ), Aug 2011

Abs DOI Bib PDF

Program queries can answer important software engineering questions that range from "which expressions are cast to this type?" over "does my program attempt to read from a closed file?" to "does my code follow the prescribed design?". In this paper, we present a comprehensive tool suite for querying Java programs. It consists of the logic program query language SOUL, the CAVA library of predicates for quantifying over an Eclipse workspace and the Eclipse plugin BARISTA for launching queries and inspecting their results. BARISTA allows other Eclipse plugins to peruse pro- gram query results which is facilitated by the symbiosis of SOUL with Java - setting SOUL apart from other program query lan- guages. This symbiosis enables the CAVA library to forego the predominant transcription to logic facts of the queried program. Instead, the library queries the actual AST nodes used by Eclipse itself, making it trivial for any Eclipse plugin to find the AST nodes that correspond to a query result. Moreover, such plugins do not have to worry about having queried stale program information. We illustrate the extensibility of our suite by implementing a tool for co-evolving source code and annotations using program queries.
@inproceedings{DeRoover2011SOUL, doi = {10.1145/2093157.2093168}, title = {The SOUL Tool Suite for Querying Programs in Symbiosis with Eclipse}, keywords = {tool support, SOUL, Eclipse}, author = {{De Roover}, Coen and {Noguera Garcia}, {Carlos Francisco} and Kellens, Andy and Jonckers, Viviane}, year = {2011}, month = aug, day = {24}, language = {English}, isbn = {978-1-4503-0935-6}, series = {International Conference on the Principles and Practice of Programming in Java (PPPJ)}, pages = {71--80}, booktitle = {International Conference on the Principles and Practice of Programming in Java (PPPJ)} }
Program Querying with a SOUL: the Barista Tool Suite

Carlos Francisco Noguera Garcia, Coen De Roover, Andy Kellens, and 1 more author

In Proceedings of the 27th IEEE International Conference on Software Maintenance (ICSM 2011), 2011

Abs DOI Bib PDF

Extracting information from the source code of a program is an important step in the way to program understanding, manipulation, development and maintenance. To this end, logic-based query languages provide a declarative manner in which to identify program elements of interest. In this paper we present BARISTA, a tool-suite for querying Java programs based on the Smalltalk Open Unification Language (SOUL). BARISTA offers programmers an advanced IDE to write queries and navigate their results. Tool builders can benefit from SOUL querying facilities by exploiting the on demand code querying and query scheduling services offered by BARISTA.
@inproceedings{NogueraGarcia2011Program, doi = {10.1109/icsm.2011.6080835}, title = {Program Querying with a SOUL: the Barista Tool Suite}, keywords = {program querying, logic meta programming, static analysis, software engineering}, author = {{Noguera Garcia}, {Carlos Francisco} and {De Roover}, Coen and Kellens, Andy and Jonckers, Viviane}, year = {2011}, language = {English}, isbn = {978-1-4577-0664-6}, series = {Proceedings of the 27th IEEE International Conference on Software Maintenance (ICSM 2011)}, booktitle = {Proceedings of the 27th IEEE International Conference on Software Maintenance (ICSM 2011)} }
Reasoning over the Evolution of Source Code using Quantified Regular Path Expressions

Andy Kellens, Coen De Roover, Carlos Francisco Noguera Garcia, and 2 more authors

In Proceedings of the 18th Working Conference on Reverse Engineering (WCRE), 2011

Abs DOI Bib PDF

Version control systems (VCS) have become indispensable to develop software. Next to their immediate advantages, they also offer information about the evolution of software and its development process. Despite this wealth of information, it has only been leveraged by tools that are dedicated to a specific software engineering task like predicting bugs or identifying hotspots. General-purpose tool support for reasoning about the information contained in a version control system is limited. In this paper, we introduce the logic-based program query language Absinth. It supports querying versioned software systems (i.e., Java versioned in Subversion or Smalltalk in either Monticello or VisualWorks Store) using logic queries in which quantified regular path expressions are embedded. These expressions lend themselves to specifying the properties that each individual version in a sequence of successive software versions ought to exhibit. We demonstrate the use of our approach for verifying process constraints, for identifying temporal bad smells and for answering questions that developers commonly ask.
@inproceedings{Kellens2011Reasoning, doi = {10.1109/wcre.2011.54}, title = {Reasoning over the Evolution of Source Code using Quantified Regular Path Expressions}, keywords = {program querying, logic meta programming, software repositories, software evolution}, author = {Kellens, Andy and {De Roover}, Coen and {Noguera Garcia}, {Carlos Francisco} and Stevens, Reinout and Jonckers, Viviane}, year = {2011}, language = {English}, isbn = {978-1-4577-1948-6}, booktitle = {Proceedings of the 18th Working Conference on Reverse Engineering (WCRE)} }

2010

Co-evolving Annotations and Source Code through Smart Annotations

Andy Kellens, Carlos Francisco Noguera Garcia, Kris De Schutter, and 2 more authors

In Conference on Software Maintenance and Reengineering (CSMR), Mar 2010

Abs DOI Bib PDF

Annotations are a means to attach additional meta data to the source code of a system. Nowadays, more and more technologies rely on the presence of such annotations in the source code: beyond their use for documentation purposes, annotations impact the behaviour of the system. Since there exists little or no support to make sure that upon evolution of the system, the source code remains correctly annotated, source code can become miss-annotated. This in turn, can result in erroneous behaviour. In this paper we present Smart Annotations, an approach for co-evolving source code and annotations. Our approach enables developers to constrain the use of annotations in the source code and offers tool support to identify conflicts between source code and annotations. To illustrate the use of our approach, we demonstrate its applicability using examples from the domain of aspect-oriented programming and Enterprise Java Beans.
@inproceedings{Kellens2010Co, doi = {10.1109/csmr.2010.20}, title = {Co-evolving Annotations and Source Code through Smart Annotations}, keywords = {co-evolution, software evolution, logic meta programming}, author = {Kellens, Andy and {Noguera Garcia}, {Carlos Francisco} and {De Schutter}, Kris and {De Roover}, Coen and D'Hondt, Theo}, year = {2010}, month = mar, language = {English}, isbn = {978-1-61284-369-8}, pages = {119--128}, booktitle = {Conference on Software Maintenance and Reengineering (CSMR)}, publisher = {IEEE Computer Society Press} }

2007

Forward chaining in HALO: an implementation strategy for history-based logic pointcuts

Charlotte Herzeel, Kris Gybels, Pascal Costanza, and 2 more authors

In Proceedings of the 2007 international conference on Dynamic languages: in conjunction with the 15th International Smalltalk Joint Conference 2007, Aug 2007

Abs DOI Bib

In aspect-oriented programming, pointcuts are formulated as conditions over the context of dynamic events in the execution of a program. Hybrid pointcut languages also allow this context to come from interactions between the pointcut language and the base program. While some pointcut languages only allow conditions on the current execution event, more recent proposals have demonstrated the need for expressing conditions over a history of join points. Such pointcut languages require means to balance the expressiveness of the language with the additional memory and runtime overhead caused by keeping a history of join point context data. In this paper, we introduce a logic-based pointcut language that allows interaction with the base program as well as pointcuts over a history of join points. We introduce forward chaining as an implementation model for this language, and discuss possible optimization strategies for the additional overhead.
@inproceedings{Herzeel2007Forward, series = {ICDL ’07}, title = {Forward chaining in HALO: an implementation strategy for history-based logic pointcuts}, url = {http://dx.doi.org/10.1145/1352678.1352689}, doi = {10.1145/1352678.1352689}, booktitle = {Proceedings of the 2007 international conference on Dynamic languages: in conjunction with the 15th International Smalltalk Joint Conference 2007}, publisher = {ACM}, author = {Herzeel, Charlotte and Gybels, Kris and Costanza, Pascal and De Roover, Coen and D’Hondt, Theo}, year = {2007}, month = aug, pages = {157–182}, collection = {ICDL ’07} }
Maintaining Design Regularities in Evolving Software Systems using Template Queries in IntensiVE: a Tool Demonstration

Johan Brichau, Coen De Roover, Andy Kellens, and 1 more author

In Proceedings of the Third International ERCIM Symposium on Software Evolution, Oct 2007

Abs Bib

Design regularities are an apparent aspect of today’s software implementations. Coding conventions, design patterns, programming idioms and architectural designs are only some examples of design regularities that govern the development of large and complex software systems. Maintaining these regularities in the source code of an evolving software system requires adequate documentation that is continuously monitored and verified for consistency with the source code. Intensional views, and their supporting tool-suite IntensiVE, permit to document and verify these regularities by means of program queries that group source code entities into views, and that impose constraints over these views. By checking the validity of the views and constraints with respect to the source-code, the tool-suite provides fine-grained feedback concerning inconsistencies between the documentation and the source code. Program queries are the heart of the IntensiVE tool-suite. Although such queries can be specified using a variety of different programming languages, the logic program query language SOUL provides developers with an expressive and declarative means to express patterns and idioms of interest. However, it can be observed that the accurate specification of such a program query can often become complex. At the core of this problem lies the observation that developers specify views based on a concrete set of source-code entities they wish to document in the system. In other words, software developers tend to understand these views not directly through its specification but through its extension, containing tangible source code entities. This dichotomy requires that developers convey their example-driven knowledge into operational queries to effectively describe a view. This is often further complicated with the fact that the specification of the view may need diverse structural and behavioral representations of the program. To reconcile the example-driven knowledge of developers with the expressive power of program queries, SOUL was recently extended with ’template queries’. Such queries are actual concrete source code templates, embedded in the logic query language. These templates describe intensional views merely through a specification of a prototypical example implementation of the regularity to search for. Furthermore, the query resolution strategy employs an automatic translation of the template to queries that act upon diverse structural and behavioral representations of the program. In particular, these queries are matched against a combination of call-graphs, points-to analysis results and abstract syntax trees.
@inproceedings{Brichau2007Maintaining, title = {Maintaining Design Regularities in Evolving Software Systems using Template Queries in IntensiVE: a Tool Demonstration}, keywords = {logic meta programming, static analysis, pattern detection}, author = {Brichau, Johan and {De Roover}, Coen and Kellens, Andy and Mens, Kim}, year = {2007}, month = oct, day = {5}, language = {English}, series = {Proceedings of the Third International ERCIM Symposium on Software Evolution}, booktitle = {Proceedings of the Third International ERCIM Symposium on Software Evolution} }
Open Unification for Program Query Languages

Johan Brichau, Coen De Roover, and Kim Mens

In Proceedings of the XXVI International Conference of the Chilean Computer Science Society (SCCC 2007), 2007

Abs DOI Bib PDF

Logic programming languages, or derivatives thereof, are increasingly applied as program query languages which allow developers to reason about the structure and behaviour of programs. Queries written in these languages can detect and verify the use of coding conventions, extract program metrics, specify pointcuts in aspect-oriented programming, and much more. To achieve this, the queried programs are reified as logic values such that logic quantification and unification can be used effectively. However, in many cases, standard logic unification is inappropriate for program entities, forcing developers to resort to overly complex queries that deal with the mismatch in unification of those entities. In this paper, we argue that such incidental complexity can be reduced significantly by customizing the unification algorithm. We present a practical implementation approach through inter-language reflection and open unification. These techniques are at the core of the logic program query language SOUL, through which we demonstrate custom unification schemes for reasoning over Smalltalk and Java programs. Queries written in this tailored version of SOUL can exploit advanced program matching strategies without increasing the incidental complexity of the queries.
@inproceedings{Brichau2007Open, doi = {10.1109/sccc.2007.4396981}, title = {Open Unification for Program Query Languages}, keywords = {logic meta programming, unification}, author = {Brichau, Johan and {De Roover}, Coen and Mens, Kim}, year = {2007}, language = {English}, series = {Proceedings of the XXVI International Conference of the Chilean Computer Science Society (SCCC 2007)}, booktitle = {Proceedings of the XXVI International Conference of the Chilean Computer Science Society (SCCC 2007)} }

Forward Chaining as an Implementation Strategy for the History-based Logic Pointcut Language HALO

Charlotte Herzeel, Kris Gybels, Pascal Costanza, and 2 more authors

In Proceedings of the 2007 International Conference on Dynamic Languages (ICDL), 2007

Abs Bib PDF

@inproceedings{Herzeel2007Forwardb,
  title = {Forward Chaining as an Implementation Strategy for the History-based Logic Pointcut Language HALO},
  keywords = {Aspect-Oriented Programming},
  author = {Herzeel, Charlotte and Gybels, Kris and Costanza, Pascal and {De Roover}, Coen and D'Hondt, Theo},
  year = {2007},
  language = {English},
  isbn = {978-1-60558-084-5},
  volume = {286},
  series = {ACM International Conference Proceeding Series},
  publisher = {ACM},
  pages = {157--182},
  editor = {Demeyer, Serge and Perrot, Jean-francois},
  booktitle = {Proceedings of the 2007 International Conference on Dynamic Languages (ICDL)}
}

Behavioral Similarity Matching using Concrete Source Code Templates in Logic Queries

Coen De Roover, Johan Brichau, Carlos Noguera, and 2 more authors

In Proceedings of the ACM/SIGPLAN Workshop on Partial Evaluation and Semantics-Based Program Manipulation (PEPM07), 2007

Abs DOI Bib PDF

Program query languages and pattern-detection techniques are an essential part of program analysis and manipulation systems. Queries and patterns permit the identification of the parts of interest in a program’s implementation through a representation dedicated to the intent of the system (e.g. call-graphs to detect behavioral flaws, abstract syntax trees for transformations, concrete source code to verify programming conventions, etc). This requires that developers understand and manage all the different representations and techniques in order to detect various patterns of interest. To alleviate this overhead, we present a logic-based language that allows the program’s implementation to be queried using concrete source code templates. The queries are matched against a combination of structural and behavioral program representations, including call-graphs, points-to analysis results and abstract syntax trees. The result of our approach is that developers can detect patterns in the queried program using source code excerpts (embedded in logic queries) which act as prototypical samples of the structure and behavior they intend to match.
@inproceedings{DeRoover2007Behavioral, doi = {10.1145/1244381.1244398}, title = {Behavioral Similarity Matching using Concrete Source Code Templates in Logic Queries}, keywords = {Source Code Templates, Program Querying, Pattern Detection, Logic Meta Programming, Program Analysis, Program Validation}, author = {{De Roover}, Coen and Brichau, Johan and Noguera, Carlos and D'Hondt, Theo and Duchien, Laurence}, year = {2007}, language = {English}, isbn = {1-59593-620-3}, booktitle = {Proceedings of the ACM/SIGPLAN Workshop on Partial Evaluation and Semantics-Based Program Manipulation (PEPM07)} }

2006

An Approach to High-Level Behavioral Program Documentation Allowing Lightweight Verification

Coen De Roover, Isabel Michiels, Kim Gybels, and 2 more authors

In Proceedings of the 14th International Conference on Program Comprehension (ICPC), 2006

Abs DOI Bib PDF

Typically, multiple developers are involved in the various stages of the software development and maintenance pro- cess. To ensure an optimal transfer of knowledge between these different peers, a reliable human-readable model of the dynamics of a software artefact is needed. Once these models become machine-veriﬁable, they can be used throughout an application’s lifetime to check whether the documented behavioral properties continue to hold as the application evolves. Unfortunately, most existing modeling media are inadequate to express human-readable behav- ioral models which are at the same time machine-veriﬁable. We therefore propose a declarative platform wherein behav- ioral program models can be expressed in terms of user- deﬁned high-level concepts and be automatically veriﬁed against an application’s actual behavior. We demonstrate our approach by using it to both document and verify an interpreter for a garbage-collected programming language.
@inproceedings{DeRoover2006Approach, doi = {10.1109/icpc.2006.10}, title = {An Approach to High-Level Behavioral Program Documentation Allowing Lightweight Verification}, author = {{De Roover}, Coen and Michiels, Isabel and Gybels, Kim and Gybels, Kris and D'Hondt, Theo}, year = {2006}, language = {English}, booktitle = {Proceedings of the 14th International Conference on Program Comprehension (ICPC)} }
Combining Fuzzy Logic and Behavioral Similarity for Non-Strict Program Validation

Coen De Roover, Johan Brichau, and Theo D’Hondt

In Proceedings of the 8th ACM-SIGPLAN International Symposium on Principles and Practice of Declarative Programming (PPDP), 2006

Abs DOI Bib PDF

The quality of an application’s implementation can be assured by validating the presence or absence of a set of user-prescribed soft- ware patterns such as software engineering best practices, program- ming conventions and indications of poor programming. Most of the existing pattern detection techniques, however, interpret pattern descriptions in an inﬂexible manner, leaving the quality assurance tool to approve only the most strictly adhering pattern implemen- tations. In order to detect various concrete pattern implementations using a single pattern description, we have combined logic meta programming —wherein patterns can be expressed as constraints over facts representing a program’s source code—, fuzzy logic and static program analysis in a way that is completely transparent to the end-user. We have achieved this by having the conditions in a logic rule interpreted as constraints over the run-time behavior source code constructs give rise to instead of as constraints over the literal source code constructs themselves. This way, a pattern’s abstract description often sufﬁces to recognize various concrete im- plementation variants with an indication of the similarity between the recognized implementation and the abstract pattern description.
@inproceedings{DeRoover2006Combining, doi = {10.1145/1140335.1140339}, title = {Combining Fuzzy Logic and Behavioral Similarity for Non-Strict Program Validation}, author = {{De Roover}, Coen and Brichau, Johan and D'Hondt, Theo}, year = {2006}, language = {English}, booktitle = {Proceedings of the 8th ACM-SIGPLAN International Symposium on Principles and Practice of Declarative Programming (PPDP)} }
Program Testing Using High-Level Property-Driven Models

Isabel Michiels, Coen De Roover, Johan Brichau, and 2 more authors

In Proceedings of the 18th International Conference on Software Engineering and Knowledge Engineering (SEKE), Jul 2006

Abs Bib PDF

Testing is a crucial part of the software development life cycle that necessitates adequate techniques and tools. On the one hand, unit testing techniques are particularly easy and lightweight to use but are restricted to testing the ex- ternal behaviour of a program. On the other hand, test- ing techniques that use property-driven models of the soft- ware are able to test behavioural properties of the entire execution of a program. However, these models are often speciﬁed in terms of low-level execution events of the pro- gram. In this paper, we present the lightweight property- driven testing platform called BEHAVE, where tests are written as property-driven behavioural models over high- level run-time events. We validate our approach by test- ing behavioural properties related to the automatic mem- ory management in the interpreter of the Pico programming language.
@inproceedings{Michiels2006Program, title = {Program Testing Using High-Level Property-Driven Models}, author = {Michiels, Isabel and {De Roover}, Coen and Brichau, Johan and {Gonzalez Boix}, Elisa and D'Hondt, Theo}, year = {2006}, month = jul, language = {English}, isbn = {1-891706-18-7}, pages = {489--494}, booktitle = {Proceedings of the 18th International Conference on Software Engineering and Knowledge Engineering (SEKE)}, publisher = {Knowledge Systems Institute} }

Journal Articles

2026

Investigating the adoption and maintenance of web GUI testing: Insights from GitHub repositories

Sergio Di Meglio, Luigi Libero Lucio Starace, Valeria Pontillo, and 3 more authors

Information and Software Technology (IST), Jan 2026

Abs DOI Bib

Context: Web GUI testing is a quality assessment practice aimed at evaluating the functionality of web applications from the perspective of its end users. While prior studies have explored the technical challenges of automated Web GUI testing, fewer works have explored how this practice is applied in real-world web apps. Objective: This study aims to investigate the adoption, characteristics, and maintenance of automated web GUI testing practices in open-source web applications, focusing on identifying trends and providing actionable insights for researchers and practitioners. Method: We conducted a large-scale empirical analysis of 472 web applications on the GitHub platform, developed in JAVA, JAVASCRIPT, PYTHON, and TYPESCRIPT. These projects use popular browser automation frameworks like SELENIUM, PLAYWRIGHT, CYPRESS, and PUPPETEER. The study involved examining project characteristics and analyzing the co-evolution and maintenance of automated web GUI tests over time. Result: Our findings empirically document automated web GUI testing adoption patterns in open-source projects, providing insights into the practical drivers behind both initial framework adoption and migration between different testing frameworks. Projects incorporating these tests generally show higher community engagement and consistent maintenance efforts. The analysis reveals that Web GUI tests tend to co-evolve with the underlying applications, reflecting their integration into the development lifecycle. Conclusion: The study provides valuable insights into the prevalence and maintenance of Web GUI testing, highlighting practical implications for improving testing practices. Our findings can guide further research on the matter and support practitioners in enhancing their testing strategies.
@article{DiMeglio2026Investigating, title = {Investigating the adoption and maintenance of web GUI testing: Insights from GitHub repositories}, volume = {189}, issn = {0950-5849}, url = {http://dx.doi.org/10.1016/j.infsof.2025.107928}, doi = {10.1016/j.infsof.2025.107928}, journal = {Information and Software Technology (IST)}, publisher = {Elsevier BV}, author = {Di Meglio, Sergio and Starace, Luigi Libero Lucio and Pontillo, Valeria and Opdebeeck, Ruben and De Roover, Coen and Di Martino, Sergio}, year = {2026}, month = jan, pages = {107928} }
The sampling threat when mining generalizable inter-library usage patterns

Yunior Pacheco Correa, Coen De Roover, and Johannes Härtel

Science of Computer Programming, Mar 2026

Abs DOI Bib PDF

Tool support in software engineering often relies on relationships, regularities, patterns, or rules mined from other users’ code. Examples include approaches to bug prediction, code recommendation, and code autocompletion. Mining is typically performed on samples of code rather than the entirety of available software projects. While sampling is crucial for scaling data analysis, it can aﬀect the generalization of the mined patterns. This paper focuses on sampling software projects ﬁltered for speciﬁc li- braries and frameworks, and on mining patterns that connect diﬀerent li- braries. We call these inter-library patterns. We observe that limiting the sample to a speciﬁc library may hinder the generalization of inter-library patterns, posing a threat to their use or interpretation. Using a simulation and a real case study, we show this threat for diﬀerent sampling methods. Our simulation shows that only when sampling for the disjunction of both libraries involved in the implication of a pattern, the implication general- izes well. Additionally, we show that real empirical data sampled using the GitHub search API does not behave as expected from our simulation. This identiﬁes a potential threat relevant for many studies that use the GitHub search API for studying inter-library patterns.
@article{PachecoCorrea2026sampling, title = {The sampling threat when mining generalizable inter-library usage patterns}, volume = {248}, issn = {0167-6423}, url = {http://dx.doi.org/10.1016/j.scico.2025.103393}, doi = {10.1016/j.scico.2025.103393}, journal = {Science of Computer Programming}, publisher = {Elsevier BV}, author = {Pacheco Correa, Yunior and De Roover, Coen and Härtel, Johannes}, year = {2026}, month = mar, pages = {103393} }

2025

An empirical evaluation of static, dynamic, and hybrid slicing of WebAssembly binaries

Quentin Stiévenart, David Binkley, and Coen De Roover

Journal of Systems and Software (JSS), Oct 2025

Abs DOI Bib PDF

The WebAssembly standard aims to form a portable compilation target, enabling the cross-platform distribution of programs written in a variety of languages. This paper introduces and evaluates novel slicing approaches for WebAssembly, including dynamic and hybrid approaches. Given a program and a location in that program, a program slice is a reduced program that preserves the behavior at the given location. A static slice does so for all possible inputs, while a dynamic slice does so for a fixed set of inputs. Hybrid slicing is a combination of static and dynamic slicing. We build on Observational-Based Slicing (ORBS), where we explore the design space for instantiating ORBS for WebAssembly. For example, ORBS can be applied to the whole program or to only the function containing the slicing criterion, and it can be applied before compilation to WebAssembly or afterwards. We evaluate the slices produced using various options quantitatively and qualitatively. Our evaluation reveals that dynamic slicing at the level of a function from a WebAssembly binary finds a sweet spot in terms of slice time and slice size, and that a combination of static and dynamic slicers achieves the best trade-off in terms of slicing time and slice size.
@article{Stivenart2025empirical, title = {An empirical evaluation of static, dynamic, and hybrid slicing of WebAssembly binaries}, volume = {228}, issn = {0164-1212}, url = {http://dx.doi.org/10.1016/j.jss.2025.112453}, doi = {10.1016/j.jss.2025.112453}, journal = {Journal of Systems and Software (JSS)}, publisher = {Elsevier BV}, author = {Stiévenart, Quentin and Binkley, David and De Roover, Coen}, year = {2025}, month = oct, pages = {112453} }
State merging for concolic testing of event-driven applications

Maarten Vandercammen and Coen De Roover

Science of Computer Programming, May 2025

Abs DOI Bib PDF

Symbolic execution has proven itself a successful technique for automatically testing applications. However, it suﬀers from the state explosion problem, where execution of the program generates an exponential number of execution states that must be explored to fully cover the program. This problem can be mitigated by incorporating state merging into the testing procedure, where execution states that are suﬃciently similar are merged together. Although state merging has been applied successfully to the testing of sequential applications, testing of event-driven applications brings with it unique challenges. In event-driven programs, the creation of new execution states is driven by both branch conditions encountered by the executor and the various permutations of the application’s event sequence, as every event sequence potentially gives rise to a unique set of execution states that are created. This article presents the ﬁrst description of how state merging can be applied in the context of symbolic execution of event-driven applications. Furthermore, although state merging has been described extensively for online symbolic execution, no mechanism has yet explicitly been described for incorporating state merging into oﬄine symbolic execution, such as concolic testing. Online symbolic executors enable forking of the execution state upon reaching a branch condition that depends on symbolic input. Such testers can explore multiple program paths simultaneously. They can hence fork and merge states whenever the opportunity arises. Oﬄine symbolic execution on the other hand, explores each program path separately. The reduced ﬂexibility complicates the application of state merging. This article provides the ﬁrst explicit overview of how state merging can be incorporated in concolic testing. We have implemented this approach to state merging in a concolic tester for event-driven JavaScript applications named StackFul. We evaluate this tester on a limited set of eight small, event-driven JavaScript web ap- plications, and ﬁnd that, within the scope of these eight applications, state merging successfully alleviates the state explosion problem, resulting in the Preprint submitted to Science of Computer Programming 15th January 2025
@article{Vandercammen2025State, title = {State merging for concolic testing of event-driven applications}, volume = {242}, issn = {0167-6423}, url = {http://dx.doi.org/10.1016/j.scico.2025.103264}, doi = {10.1016/j.scico.2025.103264}, journal = {Science of Computer Programming}, publisher = {Elsevier BV}, author = {Vandercammen, Maarten and De Roover, Coen}, year = {2025}, month = may, pages = {103264} }
A Comprehensive Study of the Lifecycle of Dormant npm Packages

Ahmed Zerouali, Valeria Pontillo, and Coen De Roover

Empirical Software Engineering (EMSE), Nov 2025

Abs DOI Bib PDF

Open-source software, with its extensive array of reusable com- ponents, is the foundation of modern software development. Package man- agers like npm simplify the integration of numerous modules and dependen- cies. While previous research has examined dependency management, security vulnerabilities, and package updates, little is known about the effects of ex- tended inactivity on these packages. This study aims to investigate the phe- nomenon of “dormant” packages and explore the implications of this dormancy on software projects and the broader open-source community. We propose a two-step investigation of the dormant packages in npm. First, we quantita- tively investigate the duration and timing of release gaps, the nature of up- dates following dormancy, and the state of dependencies during these periods of inactivity. Second, we qualitatively examine the activities of maintainers and users through an analysis of commit messages, pull requests, and issues. The key findings of our study reveal significant risks associated with dormant packages, including outdated dependencies, unpatched security vulnerabilities, and potential erosion of community trust. While some packages are eventually updated to address these issues, others remain neglected, posing challenges in using open-source software. Our study highlights the potential benefits of proactive maintenance and suggests that community involvement may play a role in mitigating the risks associated with dormant packages. Ahmed Zerouali Vrije Universiteit Brussel, Brussels, Belgium E-mail: ahmed.zerouali@vub.be Valeria Pontillo Vrije Universiteit Brussel, Brussels, Belgium Gran Sasso Science Institute (GSSI), L’Aquila, Italy E-mail: valeria.pontillo@gssi.it Coen De Roover Vrije Universiteit Brussel, Brussels, Belgium E-mail: coen.de.roover@vub.be
@article{Zerouali2025Comprehensive, title = {A Comprehensive Study of the Lifecycle of Dormant npm Packages}, volume = {31}, issn = {1573-7616}, url = {http://dx.doi.org/10.1007/s10664-025-10753-8}, doi = {10.1007/s10664-025-10753-8}, number = {1}, journal = {Empirical Software Engineering (EMSE)}, publisher = {Springer Science and Business Media LLC}, author = {Zerouali, Ahmed and Pontillo, Valeria and De Roover, Coen}, year = {2025}, month = nov }

2023

A text classification approach to API type resolution for incomplete code snippets

Camilo Velázquez-Rodríguez, Dario Di Nucci, and Coen De Roover

Science of Computer Programming, Apr 2023

Abs DOI Bib PDF

The Stack Overflow Q&A platform boasts an active community of users who often include code snippets in their questions and answers. Several development tools rely on these code snippets as a source of information. Although code snippets are intended as examples for humans, they may not form compilation units. For instance, snippets illustrating how to use an API might lack the import statements for the corresponding API types. Thus, it becomes essential to determine the fully-qualified name of API types in incomplete snippets. We present RESICO, a machine learning-based text classification approach to resolving the simple name of API types to their fully-qualified names. RESICO is trained on a corpus of Java programs for which a compiler can determine the fully-qualified names. For four machine learning classifiers, we evaluate the type resolution accuracy of the resulting models on the original and an extended version of datasets of snippets previously used to evaluate the current state-of-the-art approach based on information retrieval. Results show that our approach outperforms the state-of-the-art one, although the training phase is slightly slower. We observe that most of the incorrect type resolutions are not due to ambiguities among the simple names for API types but due to similarities among the contexts in which these types are used, representing a future research challenge.
@article{VelzquezRodrguez2023text, title = {A text classification approach to API type resolution for incomplete code snippets}, volume = {227}, issn = {0167-6423}, url = {http://dx.doi.org/10.1016/j.scico.2023.102941}, doi = {10.1016/j.scico.2023.102941}, journal = {Science of Computer Programming}, publisher = {Elsevier BV}, author = {Velázquez-Rodríguez, Camilo and Di Nucci, Dario and De Roover, Coen}, year = {2023}, month = apr, pages = {102941} }
An empirical evaluation of quasi-static executable slices

Quentin Stiévenart, David Binkley, and Coen De Roover

Journal of Systems and Software (JSS), Jun 2023

Abs DOI Bib PDF

Program slicing aims to reduce a program to a minimal form that produces the same output for a given slicing criterion. Program slicing approaches divide into static and dynamic approaches: whereas static approaches gen- erate an over-approximation of the slice that is valid for all possible program inputs, dynamic approaches rely on executing the program and thus gener- ate an under-approximation of the slice that is valid for only a subset of the inputs. An important limitation of static approaches is that they often do not generate an executable program, but rather identify only those program components upon which the slicing criterion depends (referred to as a closure slice). In order to overcome this limitation, we propose a novel approach that combines static and dynamic slicing. We rely on observation-based slicing, a dynamic approach, but protect all statements that have been identified as part of the static slice by the static slicer CodeSurfer. As a result, we obtain slices that cover at least the behavior of the static slice, and that can be compiled and executed. We evaluated this new approach on a set of 62 C programs and report our findings.
@article{Stivenart2023empirical, title = {An empirical evaluation of quasi-static executable slices}, volume = {200}, issn = {0164-1212}, url = {http://dx.doi.org/10.1016/j.jss.2023.111666}, doi = {10.1016/j.jss.2023.111666}, journal = {Journal of Systems and Software (JSS)}, publisher = {Elsevier BV}, author = {Stiévenart, Quentin and Binkley, David and De Roover, Coen}, year = {2023}, month = jun, pages = {111666} }

2022

Back to the Past – Analysing Backporting Practices in Package Dependency Networks

Alexandre Decan, Tom Mens, Ahmed Zerouali, and 1 more author

IEEE Transactions on Software Engineering, Oct 2022

Abs DOI Bib PDF

The practice of backporting aims to bring the benefits of a bug or vulnerability fix from a higher to a lower release of a software package. When such a package adheres to semantic versioning, backports can be recognised as new releases in a lower major train. This is particularly useful in case a substantial number of software packages continues to depend on that lower major train. In this article, we study the backporting practices in four popular package distributions, namely Cargo, npm, Packagist and RubyGems. We observe that many dependent packages could benefit from backports provided by their dependencies. In particular, we find that a majority of security vulnerabilities affect more than one major train but are only fixed in the highest one, letting thousands of dependent packages exposed to the vulnerability. Despite that, we find that backporting updates is quite infrequent, and mostly practised by long-lived and more active packages for a variety of reasons.
@article{Decan2022Back, title = {Back to the Past – Analysing Backporting Practices in Package Dependency Networks}, volume = {48}, issn = {2326-3881}, url = {http://dx.doi.org/10.1109/TSE.2021.3112204}, doi = {10.1109/tse.2021.3112204}, number = {10}, journal = {IEEE Transactions on Software Engineering}, publisher = {Institute of Electrical and Electronics Engineers (IEEE)}, author = {Decan, Alexandre and Mens, Tom and Zerouali, Ahmed and De Roover, Coen}, year = {2022}, month = oct, pages = {4087–4099} }
On the impact of security vulnerabilities in the npm and RubyGems dependency networks

Ahmed Zerouali, Tom Mens, Alexandre Decan, and 1 more author

Empirical Software Engineering (EMSE), May 2022

Abs DOI Bib PDF

The increasing interest in open source software has led to the emergence of large language-specific package distributions of reusable software libraries, such as npm and RubyGems. These software packages can be subject to vulnerabilities that may expose dependent packages through explicitly declared dependencies. Using Snyk’s vulnerability database, this article empirically studies vulnerabilities affecting npm and RubyGems packages. We analyse how and when these vulnerabilities are disclosed and fixed, and how their prevalence changes over time. We also analyse how vulnerable packages expose their direct and indirect dependents to vulnerabilities. We distinguish between two types of dependents: packages distributed via the package manager, and external GitHub projects depending on npm packages. We observe that the number of vulnerabilities in npm is increasing and being disclosed faster than vulnerabilities in RubyGems. For both package distributions, the time required to disclose vulnerabilities is increasing over time. Vulnerabilities in npm packages affect a median of 30 package releases, while this is 59 releases in RubyGems packages. A large proportion of external GitHub projects is exposed to vulnerabilities coming from direct or indirect dependencies. 33% and 40% of dependency vulnerabilities to which projects and packages are exposed, respectively, have their fixes in more recent releases within the same major release range of the used dependency. Our findings reveal that more effort is needed to better secure open source package distributions.
@article{Zerouali2022impact, title = {On the impact of security vulnerabilities in the npm and RubyGems dependency networks}, volume = {27}, issn = {1573-7616}, url = {http://dx.doi.org/10.1007/s10664-022-10154-1}, doi = {10.1007/s10664-022-10154-1}, number = {5}, journal = {Empirical Software Engineering (EMSE)}, publisher = {Springer Science and Business Media LLC}, author = {Zerouali, Ahmed and Mens, Tom and Decan, Alexandre and De Roover, Coen}, year = {2022}, month = may }

2021

On the practice of semantic versioning for Ansible galaxy roles: An empirical study and a change classification model

Ruben Opdebeeck, Ahmed Zerouali, Camilo Velázquez-Rodríguez, and 1 more author

Journal of Systems and Software (JSS), Dec 2021

Abs DOI Bib PDF

Ansible, a popular Infrastructure-as-Code platform, provides reusable collec- tions of tasks called roles. Roles are often contributed by third parties, and like general-purpose libraries, they evolve. Therefore, new releases of roles need to be tagged with version numbers, for which Ansible recommends adhering to the semantic versioning format. However, roles significantly differ from general- purpose libraries, and it is not yet known what constitutes a breaking change or the addition of a feature to a role. Consequently, this can cause confusion for clients of a role and new role contributors. To alleviate this issue, we perform an empirical study on semantic versioning in Ansible roles to uncover the types of changes that trigger certain types of version bumps. Our dataset consists of over 81 000 version increments spanning upwards of 8 500 Ansible roles. We design a novel structural model for these roles, and implement a domain-specific structural change extraction algorithm to calculate structural difference metrics. Afterwards, we quantitatively investigate the state of semantic versioning in Ansible roles and identify the most commonly changed elements. Then, using the structural difference metrics, we train a Random Forest classifier to predict applicable version bumps for Ansible role releases. Finally, we confirm our empirical findings with a developer survey. Our observations show that although most Ansible role developers follow the semantic versioning format, it appears that they do not always consistently follow the same rules when selecting the version bump to apply. Moreover, we find that the distinction between patch and minor increments is often unclear. Therefore, we use the gained insights to formulate a number of guidelines to apply semantic versioning on Ansible roles. These guidelines can be used by role developers to ensure a clear interpretation of the version increments.
@article{Opdebeeck2021practice, title = {On the practice of semantic versioning for Ansible galaxy roles: An empirical study and a change classification model}, volume = {182}, issn = {0164-1212}, url = {http://dx.doi.org/10.1016/j.jss.2021.111059}, doi = {10.1016/j.jss.2021.111059}, journal = {Journal of Systems and Software (JSS)}, publisher = {Elsevier BV}, author = {Opdebeeck, Ruben and Zerouali, Ahmed and Velázquez-Rodríguez, Camilo and De Roover, Coen}, year = {2021}, month = dec, pages = {111059} }
A parallel worklist algorithm and its exploration heuristics for static modular analyses

Quentin Stiévenart, Noah Van Es, Jens Plas, and 1 more author

Journal of Systems and Software (JSS), Nov 2021

Abs DOI Bib PDF

One way to speed up static program analysis is to make use of today’s multi-core CPUs by parallelising the analysis. Existing work on parallel analysis usually targets traditional data-ﬂow analyses for static, ﬁrst-order languages such as C. Less attention has been given so far to the parallelisation of more general anal- yses that can also target dynamic, higher-order languages such as JavaScript. These are signiﬁcantly more challenging to parallelise, as dependencies between analysis results are only discovered during the analysis itself. State-of-the-art parallel analyses for such languages are therefore usually limited, both in their applicability and performance gains. In this work, we propose the parallelisation of modular analyses. Modu- lar analyses compute diﬀerent parts of the analysis in isolation of one another, and therefore oﬀer inherent opportunities for parallelisation that have not been explored so far. In addition, they can be used to develop a general class of anal- ysers for dynamic, higher-order languages. We present a parallel variant of the worklist algorithm that is used to drive such modular analyses. To further speed up its convergence, we show how this algorithm can exploit the monotonicity of the analysis. Existing modular analyses can be parallelised without additional eﬀort by instead employing this parallel worklist algorithm. We demonstrate this for ModF, an inter-procedural modular analysis, and for ModConc, an inter-process modular analysis. For ModConc, we reveal an additional oppor- tunity to exploit even more parallelism in the analysis: analyses of individual ModConc components can themselves be parallel, resulting in a doubly-parallel exploration. Finally, we present several heuristics for the exploration order of the analysis and discuss how they can impact its performance. The parallel worklist algorithm and the exploration heuristics are imple- mented for and integrated into MAF, a framework for modular program analy- sis. On a set of Scheme benchmarks for ModF, we observe speedups between 3× and 8× when using 4 workers, and speedups between 8× and 32× when using 16 workers, with a maximum speedup of 333× using 128 workers. For ModConc, Email addresses: quentin.stievenart@vub.be (Quentin Sti´evenart), noah.van.es@vub.be (Noah Van Es), jens.van.der.plas@vub.be (Jens Van der Plas), coen.de.roover@vub.be (Coen De Roover) Preprint submitted to Journal of Systems and Software July 2, 2021
@article{Stivenart2021parallel, title = {A parallel worklist algorithm and its exploration heuristics for static modular analyses}, volume = {181}, issn = {0164-1212}, url = {http://dx.doi.org/10.1016/j.jss.2021.111042}, doi = {10.1016/j.jss.2021.111042}, journal = {Journal of Systems and Software (JSS)}, publisher = {Elsevier BV}, author = {Stiévenart, Quentin and Van Es, Noah and Van der Plas, Jens and De Roover, Coen}, year = {2021}, month = nov, pages = {111042} }
On the usage of JavaScript, Python and Ruby packages in Docker Hub images

Ahmed Zerouali, Tom Mens, and Coen De Roover

Science of Computer Programming, Jul 2021

Abs DOI Bib PDF

Docker is one of the most popular containerization technologies. A Docker container can be saved into an image including all environmental packages required to run it, such as system and third-party packages from language-specific package repositories. Relying on its modularity, an image can be shared and included in other images to simplify the way of building and packaging new software. However, some package managers allow to include duplicated packages in an image, increasing its footprint; and outdated packages may miss new features and bug fixes or contain reported security vulnerabilities, putting the image in which they are contained at risk. Previous research has focused on studying operating system packages within Docker images, but little attention has been given to third-party packages. This article empirically studies installation practices, outdatedness and vulnerabilities of JavaScript, Python and Ruby packages installed in 3,000 popular community Docker Hub images. In many cases, these installed packages missed important releases leading to potential vulnerabilities of the images. Our findings suggest that maintainers of Docker Hub community images should invest more effort in updating outdated packages contained in those images in order to significantly reduce the number of vulnerabilities. In addition to this, Python community images are generally much less outdated and much less subject to vulnerabilities than NodeJS and Ruby community images. Specifically for NodeJS community images, elimination of duplicate package releases could lead to a significant reduction in their image footprint.
@article{Zerouali2021usage, title = {On the usage of JavaScript, Python and Ruby packages in Docker Hub images}, volume = {207}, issn = {0167-6423}, url = {http://dx.doi.org/10.1016/j.scico.2021.102653}, doi = {10.1016/j.scico.2021.102653}, journal = {Science of Computer Programming}, publisher = {Elsevier BV}, author = {Zerouali, Ahmed and Mens, Tom and De Roover, Coen}, year = {2021}, month = jul, pages = {102653} }

2020

Prioritising Server-Side Reachability via Inter-process Concolic Testing

Maarten Vandercammen, Laurent Christophe, Dario Di Nucci, and 2 more authors

The Art, Science, and Engineering of Programming, Oct 2020

Abs DOI Bib PDF

Context: Most approaches to automated white-box testing consider the client side and the server side of a web application in isolation from each other. Such testers lack a whole-program perspective on the web application under test. Inquiry: We hypothesise that an additional whole-program perspective would enable the tester to discover which server side errors can be triggered by an actual end user accessing the application through the client, and which ones can only be triggered in hypothetical scenarios. Approach: In this paper, we explore the idea of employing such a whole-program perspective in inter-process testing. To this end, we develop StackFul, a novel concolic tester which operates on full-stack JavaScript web applications, where both the client and the server side are JavaScript processes communicating via asyn- chronous messages —as enabled by e.g., the WebSocket or Socket.IO-libraries. Knowledge: We find that the whole-program perspective enables discerning high-priority errors, which are reachable from a particular client, from low-priority errors, which are not accessible through the tested client. Another benefit of the perspective is that it allows the automated tester to construct practical, step-by- step scenarios for triggering server side errors from the end user’s perspective. Grounding: We apply StackFul on a collection of web applications to evaluate how effective inter- process testing is in distinguishing between high- and low-priority errors. The results show that StackFul correctly classifies the majority of server errors. Importance: This paper demonstrates the feasibility of inter-process testing as a novel approach for au- tomatically testing web applications. Classifying errors as being of high or low importance aids developers in prioritising bugs that might be encountered by users, and postponing the diagnosis of bugs that are less easily reached.
@article{Vandercammen2020Prioritising, title = {Prioritising Server-Side Reachability via Inter-process Concolic Testing}, volume = {5}, issn = {2473-7321}, url = {http://dx.doi.org/10.22152/programming-journal.org/2021/5/5}, doi = {10.22152/programming-journal.org/2021/5/5}, number = {2}, journal = {The Art, Science, and Engineering of Programming}, publisher = {Aspect-Oriented Software Association (AOSA)}, author = {Vandercammen, Maarten and Christophe, Laurent and Di Nucci, Dario and De Meuter, Wolfgang and De Roover, Coen}, year = {2020}, month = oct }
A large empirical assessment of the role of data balancing in machine-learning-based code smell detection

Fabiano Pecorelli, Dario Di Nucci, Coen De Roover, and 1 more author

Journal of Systems and Software (JSS), Nov 2020

Abs DOI Bib PDF

Code smells can compromise software quality in the long term by inducing technical debt. For this reason, many approaches aimed at identifying these design flaws have been proposed in the last decade. Most of them are based on heuristics in which a set of metrics is used to detect smelly code components. However, these techniques suffer from subjective interpretations, a low agreement between detectors, and threshold dependability. To overcome these limitations, previous work applied Machine-Learning that can learn from previous datasets without needing any threshold definition. However, more recent work has shown that Machine-Learning is not always suitable for code smell detection due to the highly imbalanced nature of the problem. In this study, we investigate five approaches to mitigate data imbalance issues to understand their impact on Machine Learning-based approaches for code smell detection in Object-Oriented systems and those implementing the Model-View-Controller pattern. Our findings show that avoiding balancing does not dramatically impact accuracy. Existing data balancing techniques are inadequate for code smell detection leading to poor accuracy for Machine-Learning-based approaches. Therefore, new metrics to exploit different software characteristics and new techniques to effectively combine them are needed.
@article{Pecorelli2020large, title = {A large empirical assessment of the role of data balancing in machine-learning-based code smell detection}, volume = {169}, issn = {0164-1212}, url = {http://dx.doi.org/10.1016/j.jss.2020.110693}, doi = {10.1016/j.jss.2020.110693}, journal = {Journal of Systems and Software (JSS)}, publisher = {Elsevier BV}, author = {Pecorelli, Fabiano and Di Nucci, Dario and De Roover, Coen and De Lucia, Andrea}, year = {2020}, month = nov, pages = {110693} }

2019

A general method for rendering static analyses for diverse concurrency models modular

Quentin Stiévenart, Jens Nicolay, Wolfgang De Meuter, and 1 more author

Journal of Systems and Software (JSS), Jan 2019

Abs DOI Bib

Shared-memory multi-threading and the actor model both share the notion of processes featuring communication, respectively by modifying shared state and by sending messages. Existing static analyses for concurrent programs either model every possible process interleavings and therefore suffer from the state explosion problem, or feature modularity but lack in precision or in their support for dynamic processes. In this paper we present a general method for obtaining a scalable analysis of concurrent programs featuring dynamic process creation. Our MODCONC method transforms an abstract concurrent semantics modeling processes and communication into a modular static analysis treating the behavior of processes separately from their communication. We present MODCONC in a generic way and demonstrate its applicability by instantiating it for multi-threaded and actor-based programs. The resulting analyses are evaluated in terms of precision, performance, scalability, and soundness. While a typical non-modular static analysis time out on half of our 56 benchmarks with a 30 min timeout, MODCONC analyses successfully analyze all of them in less than 30 s, while remaining on par in terms of precision. Analyzing concurrent processes in isolation while modeling their communications is the key ingredient in supporting scalable analysis of concurrent programs featuring dynamic process communication.
@article{Stivenart2019general, title = {A general method for rendering static analyses for diverse concurrency models modular}, volume = {147}, issn = {0164-1212}, url = {http://dx.doi.org/10.1016/j.jss.2018.10.001}, doi = {10.1016/j.jss.2018.10.001}, journal = {Journal of Systems and Software (JSS)}, publisher = {Elsevier BV}, author = {Stiévenart, Quentin and Nicolay, Jens and Meuter, Wolfgang De and Roover, Coen De}, year = {2019}, month = jan, pages = {17–45} }

2018

Querying distilled code changes to extract executable transformations

Reinout Stevens, Tim Molderez, and Coen De Roover

Empirical Software Engineering (EMSE), Aug 2018

Abs DOI Bib PDF

Change distilling algorithms compute a sequence of fine-grained changes that, when executed in order, transform a given source AST into a given target AST. The resulting change sequences are used in the field of mining software repositories to study source code evolution. Unfortunately, detecting and specifying source code evolutions in such a change sequence is cumbersome. We therefore introduce a tool-supported approach that identifies minimal executable subsequences in a sequence of distilled changes that implement a particular evolution pattern, specified in terms of intermediate states of the AST that undergoes each change. This enables users to describe the effect of multiple changes, irrespective of their execution order, while ensuring that different change sequences that implement the same code evolution are recalled. Correspondingly, our evaluation is two-fold. We show that our approach is able to recall different implementation variants of the same source code evolution in histories of different software projects. We also evaluate the expressiveness and ease-of-use of our approach in a user study.
@article{Stevens2018Querying, title = {Querying distilled code changes to extract executable transformations}, volume = {24}, issn = {1573-7616}, url = {http://dx.doi.org/10.1007/s10664-018-9644-3}, doi = {10.1007/s10664-018-9644-3}, number = {1}, journal = {Empirical Software Engineering (EMSE)}, publisher = {Springer Science and Business Media LLC}, author = {Stevens, Reinout and Molderez, Tim and De Roover, Coen}, year = {2018}, month = aug, pages = {491–535} }
A flexible framework for studying trace-based just-in-time compilation

Maarten Vandercammen, Stefan Marr, and Coen De Roover

Computer Languages, Systems & Structures, Jan 2018

Abs DOI Bib PDF

Just-in-time compilation has proven an effective, though effort-intensive, choice for realizing performant language runtimes. Recently introduced JIT compilation frameworks advocate applying meta-compilation techniques such as partial evaluation or meta-tracing on simple interpreters to reduce the implementation effort. However, such frameworks are few and far between. Designed and highly optimized for performance, they are difficult to experiment with. We therefore present STRAF, a minimalistic yet flexible Scala framework for studying trace-based JIT compilation. STRAF is sufficiently general to support a diverse set of language interpreters, but also sufficiently extensible to enable experiments with trace recording and optimization. We demonstrate the former by plugging two different interpreters into STRAF. We demonstrate the latter by extending STRAF with e.g., constant folding and type-specialization optimizations, which are commonly found in dedicated trace-based JIT compilers. The evaluation shows that STRAF is suitable for prototyping new techniques and formalisms in the domain of trace-based JIT compilation.
@article{Vandercammen2018flexible, title = {A flexible framework for studying trace-based just-in-time compilation}, volume = {51}, issn = {1477-8424}, url = {http://dx.doi.org/10.1016/j.cl.2017.07.005}, doi = {10.1016/j.cl.2017.07.005}, journal = {Computer Languages, Systems & Structures}, publisher = {Elsevier BV}, author = {Vandercammen, Maarten and Marr, Stefan and De Roover, Coen}, year = {2018}, month = jan, pages = {22–47} }

2017

Purity analysis for JavaScript through abstract interpretation

Jens Nicolay, Quentin Stiévenart, Wolfgang De Meuter, and 1 more author

Journal of Software: Evolution and Process, Aug 2017

Abs DOI Bib PDF

We present a static analysis for determining whether and to what extent functions in JavaScript programs are pure. To this end, the analysis classifies functions as pure functions, observers, or procedures. A function is pure if none of its executions generate or depend upon externally observable side effects. A function is an observer as soon as one of its executions depends on an external side effect, but none of its executions generate observable side effects. Otherwise, the function is classified as a procedure. Function executions and associated callers are found by traversing all reachable function execution contexts on the call stack at the point where an effect occurs. Our approach is based on a flow analysis that, in addition to computing traditional control and value flow, keeps track of read and write effects. To increase the precision of our purity analysis, we combine it with an intraprocedural analysis that determines freshness of variables and objects. We formalize the core aspects of our technique and discuss its implementation and results on common JavaScript benchmarks. Results show that our approach is capable of determining function purity in the presence of higher-order functions, dynamic property expressions, and prototypal inheritance. When compared with existing purity analyses, we find that our approach is as precise or more precise than the existing analyses.
@article{Nicolay2017Purity, title = {Purity analysis for JavaScript through abstract interpretation}, volume = {29}, issn = {2047-7481}, url = {http://dx.doi.org/10.1002/smr.1889}, doi = {10.1002/smr.1889}, number = {12}, journal = {Journal of Software: Evolution and Process}, publisher = {Wiley}, author = {Nicolay, Jens and Stiévenart, Quentin and De Meuter, Wolfgang and De Roover, Coen}, year = {2017}, month = aug }
Search-based Tier Assignment for Optimising Offline Availability in Multi-tier Web Applications

Laure Philips, Joeri De Koster, Wolfgang De Meuter, and 1 more author

The Art, Science, and Engineering of Programming, Dec 2017

Abs DOI Bib

Web programmers are often faced with several challenges in the development process of modern, rich internet applications. Technologies for the different tiers of the application have to be selected: a server-side language, a combination of JavaScript, HTML and CSS for the client, and a database technology. Meeting the expectations of contemporary web applications requires even more effort from the developer: many state of the art libraries must be mastered and glued together. This leads to an impedance mismatch problem between the different technologies and it is up to the programmer to align them manually. Multi-tier or tierless programming is a web programming paradigm that provides one language for the different tiers of the web application, allowing the programmer to focus on the actual program logic instead of the accidental complexity that comes from combining several technologies. While current tierless approaches therefore relieve the burden of having to combine different technologies into one application, the distribution of the code is explicitly tied into the program. Certain distribution decisions have an impact on crosscutting concerns such as information security or offline availability. Moreover, adapting the programs such that the application complies better with these concerns often leads to code tangling, rendering the program more difficult to understand and maintain. We introduce an approach to multi-tier programming where the tierless code is decoupled from the tier specification. The developer implements the web application in terms of slices and an external specification that assigns the slices to tiers. A recommender system completes the picture for those slices that do not have a fixed placement and proposes slice refinements as well. This recommender system tries to optimise the tier specification with respect to one or more crosscutting concerns. This is in contrast with current cutting edge solutions that hide distribution decisions from the programmer. In this paper we show that slices, together with a recommender system, enable the developer to experiment with different placements of slices, until the distribution of the code satisfies the programmer’s needs. We present a search-based recommender system that maximises the offline availability of a web application and a concrete implementation of these concepts in the tier-splitting tool Stip.js.
@article{Philips2017Searchb, title = {Search-based Tier Assignment for Optimising Offline Availability in Multi-tier Web Applications}, volume = {2}, issn = {2473-7321}, url = {http://dx.doi.org/10.22152/programming-journal.org/2018/2/3}, doi = {10.22152/programming-journal.org/2018/2/3}, number = {2}, journal = {The Art, Science, and Engineering of Programming}, publisher = {Aspect-Oriented Software Association (AOSA)}, author = {Philips, Laure and De Koster, Joeri and De Meuter, Wolfgang and De Roover, Coen}, year = {2017}, month = dec }
Implementing a performant scheme interpreter for the web in asm.js

Noah Van Es, Quentin Stievenart, Jens Nicolay, and 2 more authors

Computer Languages, Systems & Structures, Sep 2017

Abs DOI Bib PDF

This paper presents the implementation of an efficient interpreter for a Scheme-like language using manually written asm.js code. The asm.js specification defines an optimizable subset of JavaScript which has already served well as a compilation target for web applications where performance is critical. However, its usage as a human-writable language that can be integrated into existing projects to improve performance has remained largely unexplored. We therefore apply this strategy to optimize the implementation of an interpreter. We also discuss the feasibility of this approach, as writing asm.js by hand is generally not its recommended use-case. We therefore present a macro system to solve the challenges we encounter. The resulting interpreter is compared to the original C implementation and its compiled equivalent in asm.js. This way, we evaluate whether manual integration with asm.js provides the necessary performance to bring larger applications and run-times to the web. We also refactor our implementation to assess how more JavaScript code can cohabit with asm.js code, improving maintainability of the implementation while preserving near-native performance. In the case of our interpreter, this improved maintainability enables adding more complex optimizations. We investigate the addition of function inlining, for which we validate the performance gain.
@article{VanEs2017Implementing, title = {Implementing a performant scheme interpreter for the web in asm.js}, volume = {49}, issn = {1477-8424}, url = {http://dx.doi.org/10.1016/j.cl.2017.02.002}, doi = {10.1016/j.cl.2017.02.002}, journal = {Computer Languages, Systems & Structures}, publisher = {Elsevier BV}, author = {Van Es, Noah and Stievenart, Quentin and Nicolay, Jens and D’Hondt, Theo and De Roover, Coen}, year = {2017}, month = sep, pages = {62–81} }

2016

AspectJ code analysis and verification with GASR

Johan Fabry, Coen De Roover, Carlos Noguera, and 3 more authors

Journal of Systems and Software (JSS), Jul 2016

Abs DOI Bib PDF

Aspect-oriented programming languages extend existing languages with new features for supporting modularization of crosscutting concerns. These features however make existing source code analysis tools unable to reason over this code. Consequently, all code analysis efforts of aspect-oriented code that we are aware of have either built limited analysis tools or were performed manually. Given the significant complexity of building them or manual analysis, a lot of duplication of effort could have been avoided by using a general-purpose tool. To address this, in this paper we present Gasr: a source code analysis tool that reasons over AspectJ source code, which may contain metadata in the form of annotations. GASR provides multiple kinds of analyses that are general enough such that they are reusable, tailorable and can reason over annotations. We demonstrate the use of GASR in two ways: we first automate the recognition of previously identified aspectual source code assumptions. Second, we turn implicit assumptions into explicit assumptions through annotations and automate their verification. In both uses GASR performs detection and verification of aspect assumptions on two well-known case studies that were manually investigated in earlier work. GASR finds already known aspect assumptions and adds instances that had been previously overlooked.
@article{Fabry2016AspectJ, title = {AspectJ code analysis and verification with GASR}, volume = {117}, issn = {0164-1212}, url = {http://dx.doi.org/10.1016/j.jss.2016.04.014}, doi = {10.1016/j.jss.2016.04.014}, journal = {Journal of Systems and Software (JSS)}, publisher = {Elsevier BV}, author = {Fabry, Johan and De Roover, Coen and Noguera, Carlos and Zschaler, Steffen and Rashid, Awais and Jonckers, Viviane}, year = {2016}, month = jul, pages = {528–544} }

2014

A logic foundation for a general-purpose history querying tool

Reinout Stevens, Coen De Roover, Carlos Noguera, and 2 more authors

Science of Computer Programming, Dec 2014

Abs DOI Bib PDF

Version control systems (VCS) have become indispensable software development tools. The version snapshots they store to provide support for change coordination and release management, effectively track the evolution of the versioned software and its development process. Despite this wealth of historical information, it has only been leveraged by tools that are dedicated to a specific task such as empirical validation of software engineering practices or fault prediction. General-purpose tool support for reasoning about the historical information stored in a version control system is limited. This paper provides a comprehensive description of a logic-based, general-purpose history query tool called Absinthe. Absinthe supports querying versioned Smalltalk system using logic queries in which quantified regular path expressions are embedded. These expressions lend themselves to specifying the properties that each individual version in a sequence of successive software versions ought to exhibit. To demonstrate the general-purpose nature of our history query tool, we use it to verify development process constraints, to identify temporal bad smells and to answer questions that developers commonly ask. Finally, we compare a query written in Absinthe to an equivalent one written in Smalltalk.
@article{Stevens2014logic, title = {A logic foundation for a general-purpose history querying tool}, volume = {96}, issn = {0167-6423}, url = {http://dx.doi.org/10.1016/j.scico.2014.02.014}, doi = {10.1016/j.scico.2014.02.014}, journal = {Science of Computer Programming}, publisher = {Elsevier BV}, author = {Stevens, Reinout and De Roover, Coen and Noguera, Carlos and Kellens, Andy and Jonckers, Viviane}, year = {2014}, month = dec, pages = {107–120} }
The Implementation of the Cha-Q Meta-Model: A Comprehensive, Change-Centric Software Representation

Coen De Roover, Christophe Scholliers, Viviane Jonckers, and 3 more authors

Electronic Communications of the EASST (SQM), 2014

Abs Bib PDF

Although contemporary software development processes have embraced the need for continuous change, most development tools still assume that they act upon a single complete release of the system. The CHA-Q project (Change-centric Quality Assurance) aims to strike a balance between agility and reliability through change-centric quality assurance tools. These tools are to share a first-class representation of changes to software artefacts. In this paper we present the CHA-Q meta-model that defines this representation and highlight important characteristics of its implementation: an object-oriented API, persistency through a graph database, and a strategy for tracking the history of artefacts in a memory-efficient manner.
@article{DeRoover2014Implementation, title = {The Implementation of the Cha-Q Meta-Model: A Comprehensive, Change-Centric Software Representation}, keywords = {meta-model, program analysis, software change}, author = {{De Roover}, Coen and Scholliers, Christophe and Jonckers, Viviane and P{\'e}rez, Javier and Murgia, Alessandro and Demeyer, Serge}, year = {2014}, language = {English}, volume = {65}, journal = {Electronic Communications of the EASST (SQM)}, issn = {1863-2122} }

2013

CrimeSPOT: a Language and Runtime for Developing Active Wireless Sensor Network Applications

Coen De Roover, Christophe Scholliers, Wouter Amerijckx, and 2 more authors

Science of Computer Programming, 2013

Abs DOI Bib PDF

Advances in wireless sensing and actuation technology allow embedding significant amounts of application logic inside wireless sensor networks. Such active WSN applications are more autonomous, but are significantly more complex to implement. Event-based middleware lends itself to implementing these applications. It offers developers fine-grained control over how an individual node interacts with the other nodes of the network. However, this control comes at the cost of event handlers which lack composability and violate software engineering principles such as separation of concerns. In this paper, we present CrimeSPOT as a domain-specific language for programing WSN applications on top of event-driven middleware. Its node-centric features enable programming a node’s interactions through declarative rules rather than event handlers. Its network-centric features support reusing code within and among WSN applications. Unique to CrimeSPOT is its support for associating application-specific semantics with events that carry sensor readings. These preclude transposing existing approaches that address the shortcomings of event-based middleware to the domain of wireless sensor networks. We provide a comprehensive overview of the language and the implementation of its accompanying runtime. The latter comprises several extensions to the Rete forward chaining algorithm. We evaluate the expressiveness of the language and the overhead of its runtime using small, but representative active WSN applications.
@article{DeRoover2013CrimeSPOT, doi = {10.1016/j.scico.2012.07.018}, title = {CrimeSPOT: a Language and Runtime for Developing Active Wireless Sensor Network Applications}, keywords = {wireless sensor networks, ubiquitous computing, programming languages, software engineering}, author = {{De Roover}, Coen and Scholliers, Christophe and Amerijckx, Wouter and D'Hondt, Theo and {De Meuter}, Wolfgang}, year = {2013}, language = {English}, volume = {78}, pages = {1951--1970}, journal = {Science of Computer Programming}, issn = {0167-6423}, publisher = {Elsevier}, number = {10} }

2011

Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction

Sergio Castro, Coen De Roover, Andy Kellens, and 3 more authors

Science of Computer Programming, Dec 2011

Abs DOI Bib PDF

Correcting design decay in source code is not a trivial task. Diagnosing and subsequently correcting inconsistencies between a software systems’s code and its design rules (e.g., database queries are only allowed in the persistence layer) and coding conventions can be complex, time-consuming and error-prone. Providing support for this process is therefore highly desirable, but of a far greater complexity than suggesting basic corrective actions for simplistic implementation problems (like the "declare a local variable for non-declared variable" suggested by Eclipse). We present an abductive reasoning approach to inconsistency correction that consists of (1) a means for developers to document and verify a system’s design and coding rules, (2) an abductive logic reasoner that hypothesizes possible causes of inconsistencies between the system’s code and the documented rules and (3) a library of corrective actions for each hypothesized cause. This work builds on our previous work, where we expressed design rules as equality relationships between sets of source code artifacts (e.g., the set of methods in the persistence layer is the same as the set of methods that query the database). In this paper, we generalize our approach to design rules expressed as user-defined binary relationships between two sets of source code artifacts (e.g., every state changing method should invoke a persistence method). We illustrate our approach on the design of IntensiVE, a tool suite that enables defining sets of source code artifacts intensionally (by means of logic queries) and verifying relationships between such sets.
@article{Castro2011Diagnosing, doi = {10.1016/j.scico.2010.09.001}, title = {Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction}, keywords = {Abductive reasoning, IntensiVE}, author = {Castro, Sergio and {De Roover}, Coen and Kellens, Andy and Lozano, Angela and Mens, Kim and D'Hondt, Theo}, year = {2011}, month = dec, day = {1}, language = {English}, volume = {76}, pages = {1113--1129}, journal = {Science of Computer Programming}, issn = {0167-6423}, publisher = {Elsevier}, number = {Special Issue on Software Evolution, Adaptability} }

2009

Forward Chaining in HALO - An Implementation Strategy for History-based Logic Pointcuts

Charlotte Herzeel, Kris Gybels, Pascal Costanza, and 4 more authors

Computer Languages, Systems and Structures, Apr 2009

Abs DOI Bib

In aspect-oriented programming, pointcuts are formulated as conditions over the context of dynamic events in the execution of a program. Hybrid pointcut languages also allow this context to come from interactions between the pointcut language and the base program. While some pointcut languages only allow conditions on the current execution event, more recent proposals have demonstrated the need for expressing conditions over a history of join points. Such pointcut languages require means to balance the expressiveness of the language with the additional memory and runtime overhead caused by keeping a history of join point context data. In this paper, we introduce a logic-based pointcut language that allows interaction with the base program as well as pointcuts over a history of join points. We introduce forward chaining as an implementation model for this language, and discuss possible optimization strategies for the additional overhead.
@article{Herzeel2009Forward, doi = {10.1016/j.cl.2008.06.002}, title = {Forward Chaining in HALO - An Implementation Strategy for History-based Logic Pointcuts}, keywords = {aspect-oriented programming, temporal logic, Common Lisp, RETE forward chaining}, author = {Herzeel, Charlotte and Gybels, Kris and Costanza, Pascal and {De Roover}, Coen and D'Hondt, Theo and Demeyer, Serge and Perrot, Jean-francois}, year = {2009}, month = apr, language = {English}, volume = {35}, pages = {31--47}, journal = {Computer Languages, Systems and Structures}, publisher = {Elsevier Limited} }

2005

Towards Abstract Interpretation for Recovering Design Information

Coen De Roover, Kris Gybels, and Theo D’Hondt

In Proceedings of the First International Workshop on Abstract Interpretation of Object-oriented Languages (AiOOL), 2005

Abs DOI Bib PDF

Interpretation for Recovering Design Information Coen De Roover, Kris Gybels 1, Theo D’Hondt Programming Technology Lab Vrije Universiteit Brussel Brussels, Belgium cderoove, kris.gybels, tjdhondt@vub.ac.be Abstract It is a well-known problem that design information of object-oriented programs is often lost or is not kept up-to-date when the program evolves. This design in- formation can be recovered from the program using such techniques as logic meta programming. In this technique logic queries are used to check whether the program is implemented along certain well-known patterns. Currently the technique relies on structural information and patterns are expressed in the queries as conditions over structural elements of the program. Some patterns are however better expressed in dynamic terms which requires behavioural information about the program. Such information can be obtained from execution traces of the program, but these record only one possible input dependent program execution out of many. Abstract in- terpretation of the object-oriented program could provide a well-founded means for extracting the necessary behavioural information.
@inproceedings{DeRoover2005Towards, doi = {10.1016/j.entcs.2005.01.019}, title = {Towards Abstract Interpretation for Recovering Design Information}, author = {{De Roover}, Coen and Gybels, Kris and D'Hondt, Theo}, year = {2005}, language = {English}, volume = {131}, series = {Electronic Notes in Theoretical Computer Science}, publisher = {Proceedings of the First International Workshop on Abstract Interpretation of Object-oriented Languages (AIOOL 2005), Electronic Notes in Theoretical Computer Science Volume 131, Pages 15-25}, pages = {15--25}, booktitle = {Proceedings of the First International Workshop on Abstract Interpretation of Object-oriented Languages (AiOOL)} }

Workshop Papers

2024

Aran: JavaScript Instrumentation for Heavyweight Dynamic Analysis

Laurent Christophe, Coen De Roover, and Wolfgang De Meuter

In Proceedings of the 23rd Belgium-Netherlands Software Evolution Workshop (BENEVOL 2024), 2024

Abs Bib PDF

We introduce aran, a novel approach for developing heavyweight dynamic analyses of JavaScript programs. Our approach is broadly applicable, relying solely on source code instrumentation. It also supports complex customization through an intuitive aspect-oriented API, which consists of 31 entry points. With about 300 lines of code, our API can express an analysis that computes the symbolic execution tree of run-time values. Importantly, our approach preserves the semantics of the program under analysis. We implemented this approach in a tool and validated it using Test262, the official JavaScript conformance test suite, achieving a 99.7% success rate and observing performance slowdowns rarely exceeding 10x.
@inproceedings{Christophe2024Aran, title = {Aran: JavaScript Instrumentation for Heavyweight Dynamic Analysis}, author = {Christophe, Laurent and {De Roover}, Coen and {De Meuter}, Wolfgang}, booktitle = {Proceedings of the 23rd Belgium-Netherlands Software Evolution Workshop (BENEVOL 2024)}, address = {Namur, Belgium}, year = {2024}, }
Resilience Testing of Spring Applications via Fault Injections

Camilo Velázquez-Rodríguez, Warren Gaure, and Coen De Roover

In Resilience Testing of Spring Applications via Fault Injections (BENEVOL), 2024

Abs Bib PDF

Nowadays, there exist multiple forms of testing such as unit tests, integration tests, etc. Another form of testing is resilience testing, which tests the endurance of a target system by injecting faults and observing the system’s behaviour. Injected faults such as aborting messages or bringing down services aim to dramatically perturb thetarget system. This paper proposes a tool for resilience testing of microservices in Spring applications. Our tool takes as input a set of manually written scenarios to inject abort and delay faults between different microservices in a target application. After parsing the written scenarios, our tool identifies the subset of tests in the targetapplication that use the Spring REST API. As a microservice application might consist of multiple modules or services, our tool also scans all modules to later execute the selected application tests properly. Finally, we inject faults into microservices and observe the system’s behaviour. We demonstrate the effectiveness of our tool byapplying it to an open-source Spring project.
@inproceedings{VelazquezRodriguez2024Resilience, title = {Resilience Testing of Spring Applications via Fault Injections}, keywords = {microservices, fault injection, resilience testing, spring apps}, author = {Vel{\'a}zquez-Rodr{\'i}guez, Camilo and Gaure, Warren and {De Roover}, Coen}, year = {2024}, language = {English}, volume = {3941}, pages = {54--64}, editor = {Perrouin, Gilles and Vanderose, Beno{\^i}t and Devroey, Xavier}, booktitle = {Resilience Testing of Spring Applications via Fault Injections (BENEVOL)}, publisher = {CEUR Workshop Proceedings} }
FERRARI: FailurE RepRoduction through automatic test cAse generation and stack tRace analysIs

Valeria Pontillo, Maarten Vandercammen, Sarah Verbelen, and 1 more author

In BENEVOL24: The 23rd Belgium-Netherlands Software Evolution Workshop (BENEVOL), 2024

Abs Bib PDF

As cloud services grow increasingly complex, their REST APIs become more susceptible to failures causedby unforeseen interactions between API calls or bugs in service implementations. Debugging thesefailures involves two key steps: reproducing the failure and identifying the root cause. In distributedenvironments, reproducing failures is particularly challenging due to the need to reconstruct the intricatesequence of API calls that lead to the issue. Identifying the defect then requires analyzing stack traces,which can be difficult and time-consuming due to the volume of logs and the variability of interactionsacross the system. While tools like RESTler can automate testing and uncover bugs, the manual analysisof stack traces to pinpoint the root cause of failures remains challenging and time-consuming. Tostreamline this process, we propose FERRARI, an extension of RESTler that automates the mappingof stack traces to generate targeted test cases for failure reproduction. FERRARI introduces a novelsimilarity scoring mechanism to quantify how closely the behavior of generated test cases matches theconditions of the initial failure, enabling efficient reproduction and diagnosis. By filtering irrelevant testcases and focusing on high-similarity candidates, FERRARI reduces the number of requests sent whilepreserving precision. In this way, FERRARI helps developers by reducing the number of stack traces thatneed to be manually analyzed. Our evaluation demonstrates that FERRARI achieves the same level offailure reproduction as baseline fuzzing strategies but with significantly fewer requests and error logs,offering a scalable and effective solution for developers.
@inproceedings{Pontillo2024FERRARI, title = {FERRARI: FailurE RepRoduction through automatic test cAse generation and stack tRace analysIs}, keywords = {REST API, Software Testing, Failure Reproduction}, author = {Pontillo, Valeria and Vandercammen, Maarten and Verbelen, Sarah and {De Roover}, Coen}, year = {2024}, language = {English}, volume = {3941}, pages = {177--189}, booktitle = {BENEVOL24: The 23rd Belgium-Netherlands Software Evolution Workshop (BENEVOL)}, publisher = {CEUR Workshop Proceedings}, edition = {23} }
Integrating Fault Injection in Fuzzing: Design, Implementation and Preliminary Experiments

Gilles Coremans and Coen De Roover

In BENEVOL24: The 23rd Belgium-Netherlands Software Evolution Workshop (BENEVOL), Nov 2024

Abs Bib PDF

While microservice architectures offer many advantages to developers of web applications, it remains difficult to test the resilience of these applications to faults. Common approaches such as chaos engineering require dedicated personnel and carry the risk of the testing taking place in a production environment, while resilience testing tools require specifying execution scenarios and cannot test paths not exercised by those scenarios.In this paper, we introduce \Onweer, a resilience tester which integrates coverage-guided fuzzing and fault injection. Fuzzing is used to explore the execution space of the application and to collect potential fault injection points. Subsequent fuzzing iterations can then inject faults as part of the fuzzing process. That is, faults are added to test cases by mutators applied to the population, and if they increase coverage these test cases with faults are added to the population for further mutation.We evaluate this approach by using three case studies of the retry resilience pattern and find that Onweer is able to both increase coverage by exploring otherwise inaccessible branches and reveal resilience defects.
@inproceedings{Coremans2024Integrating, title = {Integrating Fault Injection in Fuzzing: Design, Implementation and Preliminary Experiments}, keywords = {Fuzzing, Fault Injection, Resilience, Microservices, REST}, author = {Coremans, Gilles and {De Roover}, Coen}, year = {2024}, month = nov, language = {English}, volume = {3941}, pages = {52--62}, booktitle = {BENEVOL24: The 23rd Belgium-Netherlands Software Evolution Workshop (BENEVOL)}, publisher = {CEUR Workshop Proceedings}, edition = {23} }
Abstract Slicing To Improve The Speed Of Static Program Analysis

Sarah Verbelen, Bram Vandenbogaerde, Jens Van der Plas, and 2 more authors

In Proceedings of the 23rd Belgium-Netherlands Software Evolution Workshop (BENEVOL 2024), 2024

Abs Bib PDF

Slicing To Improve The Speed Of Static Program Analysis Sarah Verbelen1, Bram Vandenbogaerde1, Jens Van der Plas1, Noah Van Es1 and Coen De Roover1 1Vrije Universiteit Brussel, Brussels, Belgium Abstract When performing a static analysis, there is a trade-off between the time it takes to run the analysis and the quality of the results of the analysis. We propose to run the analysis on an abstract slice to reduce the size of the program to be analysed without impacting the results of the analysis. We adapt an abstract slicing algorithm to produce executable abstract slices that can be analysed using abstract interpretation. Next, we implement an intraprocedural abstract slicer for Scheme programs. We evaluate the implementation using a dataset of 1050 randomly generated Scheme programs. We find that abstract slices are in general smaller than their corresponding concrete slices and that in turn they are analysed faster. Additionally, we find that there is a significant difference between the abstract slices for two different abstract domains.
@inproceedings{Verbelen2024Abstract, title = {Abstract Slicing To Improve The Speed Of Static Program Analysis}, author = {Verbelen, Sarah and Vandenbogaerde, Bram and {Van der Plas}, Jens and {Van Es}, Noah and {De Roover}, Coen}, booktitle = {Proceedings of the 23rd Belgium-Netherlands Software Evolution Workshop (BENEVOL 2024)}, address = {Namur, Belgium}, year = {2024}, }

2022

LiFUSO: A Tool to Improve Library Selection in Maven

Camilo Ernesto Velazquez Rodriguez and Coen De Roover

In The 21st Belgium-Netherlands Software Evolution Workshop (BENEVOL), 2022

Abs Bib

Libraries in a software ecosystem target a well-defined domain (e.g., PDF, collections, etc.) and offer functionalities to client systems through their API. The instantiation of one or multiple APIs enables the implementation of a particular task within the domain (e.g., inserting an image, serialising to JSON, reversing a list, etc.). Maven, NPM or CRAN are examples of software ecosystems which provide a vast number of libraries offering multiple features for their reuse. At library selection time from a vast ecosystem, it becomes essential for developers to know the enumeration of features offered by each library. Such a possibility is not currently available in existing software ecosystems. The selection of libraries is currently based on popularity metrics (which can be biased by the number of developers who have used the library) and not the features they provide, defining features as a set of API references n : n >= 1 and the textual description of the offered functionality[1,2]. Furthermore, there is currently no way to compare libraries feature-wise, which can ultimately improve their selection. To alleviate the absence of descriptions of features of libraries, developers often pose questions on Q&A websites like Stack Overflow (SO) to get information about how to realise particular tasks. Therefore, the solutions on sites like SO provide a variety of feature examples that enhance library documentation, enable cross-library comparison by users, and improve recommendation tools of third-party libraries. We present our tool for Library Feature Unveiling from Stack Overflow (LiFUSO) posts as an initial approach to improving the selection of libraries in the Maven software ecosystem. LiFUSO was developed based on the proposed approach by Velázquez-Rodríguez [3]. The tool takes advantage of the natural language terms around API reference usages to discover features with their corresponding name. The input of LiFUSO is a target library for which features need to be computed. Our tool requires that the \emphgroupID and artifactID (e.g., com.google.guava and guava respectively) of at least one version of the library is available from the Maven Central repository. The name of the target library needs also to be a valid SO tag. In this abstract, we briefly describe the main components of LiFUSO and provide a simple example of its usage: Collecting Information: The first step collects the names of API elements as well as answers from SO that might contain usages of these elements by downloading all versions of the library from Maven and processing their bytecode. SO answers are obtained from the SOTorrent dataset by searching posts with the name of the library among their tags. Filtering: This step first excludes answers without any code snippets. As SO code snippets are not necessarily complete nor syntactically correct, LiFUSO relies on a robust parser generated by a custom-built island grammar to this end. Our custom parser focuses on the syntactic constructs in which method invocations from the target library can occur. Clustering and Naming: This step constructs a matrix of the Jaccard similarity between all SO answers based on their usage of the library’s API elements. Next, it applies hierarchical clustering to the matrix and by means of a dynamic cut tree technique, selects the optimal cutting point to form clusters. Using the local outlier factor (LOF) technique, the most frequent API elements within the cluster are identified. In case LOF cannot determine such elements, the cluster is discarded. A semantic tree is computed for the sentences in the title of and the text surrounding each SO answer. For each noun and verb, LiFUSO extracts pairs of the form noun-verb or verb-noun. The most frequent verbs and nouns in the pairs (using LOF once again) are retained. Representing Features: LiFUSO selects the top-5 most frequent pairs as representations for the name of the feature. In the case of the selection for API references in the clustered snippets, LiFUSO selects those extracted from the LOF technique in a previous step. Clusters with the most frequent name pairs and API references are outputted. Exploring Features: Shared features of the libraries are calculated as well as the unique functionalities per pair of libraries. Finally, all the previously described information is displayed in a visual interface for feature exploration and library comparisons feature-wise. At BENEVOL, we intend to present our tool, the limitations it currently has, and the future avenues our tool might take.
@inproceedings{VelazquezRodriguez2022LiFUSOb, booktitle = {The 21st Belgium-Netherlands Software Evolution Workshop (BENEVOL)}, title = {LiFUSO: A Tool to Improve Library Selection in Maven}, author = {{Velazquez Rodriguez}, {Camilo Ernesto} and {De Roover}, Coen}, year = {2022}, language = {English}, url = {https://benevol2022.github.io/} }

2021

Stack Overflow Posts as Source of Library Features

Camilo Ernesto Velazquez Rodriguez, Eleni Constantinou, and Coen De Roover

In 20th Belgium-Netherlands Software Evolution Workshop (BENEVOL), Dec 2021

Abs Bib

It is common in contemporary software development to reuse functionality from third-party libraries in order to reduce development time and to improve overall system quality [1]. Each library targets a well-defined domain (e.g., GUI, persistence) and offers functionality to client systems through its API, facilitating the implementation of a particular task within the domain (e.g., displaying a dialog, serialising to JSON). Software ecosystems such as Maven or NPM provide a vast number of libraries that offer different features for reuse. When selecting a library to reuse from a vast ecosystem, it becomes essential for developers to know the features offered by each library. Kanda et.al [2] consider a set of API methods with a corresponding name as a feature. We generalise their definition in this work so that features comprise the API elements that realise them, and the textual description of the offered functionality. To alleviate the absence of descriptions of features of libraries, developers often pose questions in Q&A websites like Stack Overflow (SO) to get information about how to realise particular tasks. For example, a post asks about possible ways to delete a directory recursively and a code example of the Apache Commons IO library is offered as a solution. Therefore, the solutions on sites like SO can provide a variety of feature examples that can enhance library documentation, to enable cross-library comparison by users, and to improve recommendation tools of third-party libraries. We present an approach to extracting the functional features of a library using the library’s JAR files and the \so posts where it is used. The latter present a unique opportunity for API mining because of their focus on a particular domain task, and because of the natural language that surrounds code snippets. By verifying the API calls in a snippet w.r.t. the API of the target library, we can ensure the validity of the example. The approach can form the foundation for exploring an ecosystem through the features offered by its libraries: Data Collection: Our approach requires that the groupID and artifactID of at least one version of a library is in the Maven Central repository. Then, it collects information about its public API from their published JAR files, and example usages of this API from SO snippets. A heuristic based on the tags of the SO answer is used to select code snippets related to the library under analysis. For each selected answer, the following information is collected for subsequent processing: the body of the question, the body of the answer, and the title. Data Processing: The approach filters out all answers without a code snippet (e.g., many answers related to the Weka library). We designed a custom-built island grammar based on the official Java Language Specification that is capable of parsing code snippets that are incomplete or syntactically incorrect. A parser based on this island grammar extracts the API information we are interested in, e.g., invocations of both instance and static methods. The approach uses the information extracted from the public API of a library to match types (i.e., classes) and methods that are part of a library. Data Transformation: This step is different depending on the type of information to transform, i.e., the text or code from an SO answer. In the case of text attributes such as the bodies of the question and answer and their title, the data is cleaned and then a TF-IDF model is trained. Such a model will allow transforming text into numerical vectors. The distance between the vectors is calculated through the cosine metric resulting in a similarity matrix, e.g., every number d_ij in the matrix is the distance between the vectors i and j. Similarly, for code attributes (i.e., the original method names, the method names after splitting camel case, and the API usage itself as extracted by the island parser) a similarity matrix is obtained through the Jaccard index. Clustering, selecting and naming: The similarity matrices obtained in a previous step are the input to a hierarchical clustering algorithm. A dynamic tree cutting approach is adopted to select the optimal cutting point in the dendrogram. The ideal cluster would be that one in which the feature is clearly depicted; which might not always be the case. We use the local outlier factor (LOF) to check the most common elements within a cluster. From the textual information, the approach extracts pairs noun-verb or verb-noun. The most frequent pairs (extracted with LOF) will form the cluster name. At BENEVOL, we intend to present our approach, the results from its evaluation, the limitations we currently have, and the future avenues our work might take.
@inproceedings{VelazquezRodriguez2021Stack, booktitle = {20th Belgium-Netherlands Software Evolution Workshop (BENEVOL)}, title = {Stack Overflow Posts as Source of Library Features}, keywords = {features, libraries, Stack Overflow}, author = {{Velazquez Rodriguez}, {Camilo Ernesto} and {Eleni Constantinou} and {De Roover}, Coen}, year = {2021}, month = dec, language = {English}, url = {https://benevol2021.github.io} }
Wassail: a WebAssembly Static Analysis Library

Quentin Stiévenart and Coen De Roover

In Fifth International Workshop on Programming Technology for the Future Web (ProWeb), Mar 2021

Abs Bib

In this presentation, we present our work on Wassail, a static analysis library for WebAssembly. Our goal is to facilitate the development of various static analyses for WebAssembly, by providing a set of useful building blocks from which analyses can be constructed. We aim to support both lightweight static analyses such as code querying, as well as heavyweight static analyses such as dataflow analyses. Wassail is still in an early development phase and we are interested in feedback from the community to steer its future development.
@inproceedings{Stievenart2021Wassail, booktitle = {Fifth International Workshop on Programming Technology for the Future Web (ProWeb)}, title = {Wassail: a WebAssembly Static Analysis Library}, keywords = {WebAssembly, static analysis}, author = {Sti{\'e}venart, Quentin and {De Roover}, Coen}, year = {2021}, month = mar, day = {22}, language = {English}, url = {https://2021.programming-conference.org/home/proweb-2021} }

2019

A language-parametric modular framework for mining idiomatic code patterns

D.D. Nucci, H.S. Pham, J. Fabry, and 5 more authors

CEUR Workshop Proceedings, 2019

Abs Bib

In an ongoing industry-university collabora- tion we are developing a language-parametric framework for mining code idioms in legacy systems. This modular framework has a pipeline architecture and a language- parametric meta representation of the arte- facts used by each of its 5 components: source code importer, mining preprocessor, pattern miner, pattern matcher, and modernisation assistant. The pipeline enables reuse of its components across systems and languages, as well as for project partners to work on each of these components separately. An exam- ple is the exploration of novel pattern mining techniques independently of the languages on which they will be applied and the modernisa- tion assistant in which they will be used. Our ﬁrst results on mining Java and COBOL code are promising, even though challenges still lie ahead to make the framework and its consti- tuting components truly scalable, customis- able, and language independent.
@article{Nucci2019language, title = {A language-parametric modular framework for mining idiomatic code patterns}, journal = {CEUR Workshop Proceedings}, year = {2019}, volume = {2510}, author = {Nucci, D.D. and Pham, H.S. and Fabry, J. and De Roover, C. and Mens, K. and Molderez, T. and Nijssen, S. and Zaytsev, V.} }
On the role of data balancing for machine learning-based code smell detection

Fabiano Pecorelli, Dario Di Nucci, Coen De Roover, and 1 more author

In Proceedings of the 3rd ACM SIGSOFT International Workshop on Machine Learning Techniques for Software Quality Evaluation (MaLTeSQuE), Aug 2019

Abs DOI Bib PDF

Code smells can compromise software quality in the long term by inducing technical debt. For this reason, many approaches aimed at identifying these design flaws have been proposed in the last decade. Most of them are based on heuristics in which a set of metrics (e.g., code metrics, process metrics) is used to detect smelly code components. However, these techniques suffer of subjective interpretation, low agreement between detectors, and threshold dependability. To overcome these limitations, previous work applied Machine Learning techniques that can learn from previous datasets without needing any threshold definition. However, more recent work has shown that Machine Learning is not always suitable for code smell detection due to the highly unbalanced nature of the problem. In this study we investigate several approaches able to mitigate data unbalancing issues to understand their impact on ML- based approaches for code smell detection. Our findings highlight a number of limitations and open issues with respect to the usage of data balancing in ML-based code smell detection. CCS CONCEPTS • Software and its engineering →Software maintenance tools. KEYWORDS Code Smells, Machine Learning, Data Balancing
@inproceedings{Pecorelli2019role, series = {ESEC/FSE ’19}, title = {On the role of data balancing for machine learning-based code smell detection}, url = {http://dx.doi.org/10.1145/3340482.3342744}, doi = {10.1145/3340482.3342744}, booktitle = {Proceedings of the 3rd ACM SIGSOFT International Workshop on Machine Learning Techniques for Software Quality Evaluation (MaLTeSQuE)}, publisher = {ACM}, author = {Pecorelli, Fabiano and Di Nucci, Dario and De Roover, Coen and De Lucia, Andrea}, year = {2019}, month = aug, pages = {19–24}, collection = {ESEC/FSE ’19} }

2018

Mete: A meta rete interface for distributed rule-based systems

M. Hubrechts, K. Kambona, T. Renaux, and 4 more authors

CEUR Workshop Proceedings, 2018

Abs Bib

In Complex Event Processing (CEP), continuous streams of information are analyzed to deduce useful insights from the incoming data. CEP can be implemented using rule- based systems. These are systems which are used to act upon states in which an object domain can be. It does so by providing facts that represent that object domain and rules that describe when certain actions must happen. In order to determine this, a rule interpreter is used to ﬁnd the rules that match the available facts. A widely used example of such an interpreter is the Rete algorithm. However, since Rete was ﬁrst introduced in the seventies, changes to the algorithm are needed to make it relevant to today’s standards in CEP. One of those changes is the support for deployment in a cloud setting or on a computer cluster to enhance the processing performance. Previous research describes a distributed variant of the Rete algorithm which distributes the workload across a computer cluster. Inescapably, distributing the work over different machines introduces additional meta- concerns such as load balancing and fault tolerance. In this paper, we claim that the complexity of maintaining CEP systems can be reduced by disentangling these meta- concerns from the base application. We introduce a meta Rete system called Mete. Mete reasons about, and intercedes in, a distributed base Rete network. Mete allows programmers to add and modify meta-concerns such as auditing, fault tolerance, load balancing, or logging, without requiring any modiﬁcation to the base application code.
@article{Hubrechts2018Mete, title = {Mete: A meta rete interface for distributed rule-based systems}, journal = {CEUR Workshop Proceedings}, year = {2018}, volume = {2361}, author = {Hubrechts, M. and Kambona, K. and Renaux, T. and Van de Water, S. and Saey, M. and De Roover, C. and De Meuter, W.} }
Mining extension point patterns in scala

Y. Pacheco, J. De Bleser, T. Molderez, and 3 more authors

CEUR Workshop Proceedings, 2018

Abs Bib

To use a framework, developers often need to hook into and customize some of its functionality. These customizations are often made by instantiating a type provided by the frame- work, or by extending or implementing a framework type and instantiating this subtype, and providing the resulting object to other framework objects. Recommending extension patterns that frequently occur at such extension points can help developers to adopt a new framework correctly and to exploit it fully. In this paper we transpose an existing technique for mining extension patterns in Java projects to the Scala context. Our goal is to evaluate whether the unique features of the Scala language have an impact on the mined extension patterns. To this aim, we propose SCALA-XP-MINER, a tool for mining extension point patterns in Scala projects. We preliminary evaluate SCALA-XP- MINER on a corpus of 9 projects using the SWING framework. Our ﬁrst results reveal that extension points are not very diffused in Scala projects using SWING and that only one type of extension points is adopted by developers.
@article{Pacheco2018Mining, title = {Mining extension point patterns in scala}, journal = {CEUR Workshop Proceedings}, year = {2018}, volume = {2361}, author = {Pacheco, Y. and De Bleser, J. and Molderez, T. and Nucci, D.D. and De Meuter, W. and De Roover, C.} }
Concolic testing of full-stack javascript applications

M. Vandercammen, L. Christophe, W. De Meuter, and 1 more author

CEUR Workshop Proceedings, 2018

Abs Bib

Recent years have seen the rise of so-called full-stack JavaScript web applications, where both the client and the server side of the web application are developed in JavaScript. Both sides communicate with each other via asynchronous messages, as enabled by e.g., WebSockets. Traditionally, automated whitebox testing of web applications involves testing both sides of the application in isolation from each other. However, this approach lacks a holistic overview of the entire web application under test. This leads to inaccuracies in the types of program bugs that are reported by the tester, and makes it more difﬁcult for developers to understand how the behaviour of the client may affect the behaviour of the server, and vice versa. An interesting side-effect of the evolution towards full-stack applications is that a single automated tester can be developed that observes the execution of both parts of the system simultaneously, thereby remedying the aforementioned issues. In this paper, we examine the beneﬁts and design challenges in employing such a holistic approach towards testing full-stack applications, and we demonstrate STACKFUL, the ﬁrst concolic tester for full-stack JavaScript applications.
@article{Vandercammen2018Concolic, title = {Concolic testing of full-stack javascript applications}, journal = {CEUR Workshop Proceedings}, year = {2018}, volume = {2361}, author = {Vandercammen, M. and Christophe, L. and De Meuter, W. and De Roover, C.} }

2017

Employing Run-time Static Analysis to Improve Concolic Execution

M. Vandercammen and C. De Roover

CEUR Workshop Proceedings, 2017

Abs Bib

Dynamic symbolic execution, or concolic execution, is a program testing technique that systematically executes a program with the aim of exploring all feasible program paths, and locating and reporting all errors encountered in these paths. However, as the complexity of the program grows, the number of program paths explodes, making it infeasible for concolic testers to explore all of them. To reduce the number of paths to explore, several concolic testing tools have recently started employing static analysis to prune paths guaranteed by the static analysis to be safe. The concolic tester must then only focus on those paths that might contain an error, as reported by the analysis. However, due to imprecisions in the analysis’ result, the reported errors may just be false positives, and it is up to the tester to verify whether a reported alarm is an actual error or merely a false positive. In this position paper, we propose to increase the precision of these analyses by not only performing an initial static analysis before starting concolic testing of the program, but also by launching incremental static analyses over the program at run time, and incorporating into the analyses run-time information observed by the tester. The increased precision that results from incorporating such run-time information should enable further pruning of the program paths that must be explored by the concolic tester.
@article{Vandercammen2017Employing, title = {Employing Run-time Static Analysis to Improve Concolic Execution}, journal = {CEUR Workshop Proceedings}, year = {2017}, volume = {2047}, pages = {26-29}, author = {Vandercammen, M. and De Roover, C.} }
Towards a Domain-Specific Language for Automated Network Management

T. Molderez, C. De Roover, and W. De Meuter

CEUR Workshop Proceedings, 2017

Abs Bib

Software applications involving networks, in a broad sense of the term, are becoming more complex and are deployed on a growing number of devices. These applications can involve wireless sensor networks, smart grids, intelligent trafﬁc light sys- tems, and so on. Manually managing such networks is becoming increasingly difﬁcult. To automate this management process, this paper introduces the initial design of the Marlon domain-speciﬁc language. Marlon is suited to specify the desired management policies that should be achieved. It can automatically apply these policies using machine learning techniques, effectively reducing the amount of effort needed to manage such systems.
@article{Molderez2017Towards, title = {Towards a Domain-Specific Language for Automated Network Management}, journal = {CEUR Workshop Proceedings}, year = {2017}, volume = {2047}, pages = {39-43}, author = {Molderez, T. and De Roover, C. and De Meuter, W.} }
Modular Static Analysis of Actor Programs

Quentin Stiévenart, Jens Nicolay, Coen De Roover, and 1 more author

In BElgian-NEtherlands eVOLution seminar 2017 (BENEVOL), Dec 2017

Abs Bib

Existing static analyses for actor programs ex- plicitely model all possible execution interleavings. Because the number of interleavings increases exponentially with the number of actors and messages exchanged, such analyses scale poorly. We describe the first modular analysis for actor programs, that analyzes each actor in separation of each other. This analysis over-approximate over the diferent interleavings without explicitly modeling them, rendering it scalable. We demonstrate its enhanced scalability by comparing the analysis of the Savina benchmark suite with a non-modular analysis and our new modular analysis. Our technique succeeds in analyzing all of the Savina benchmarks in a matter of seconds, while the non-modular analysis times out on more than half of these benchmarks. Moreover, we show that the precision of our modular remains on par with the precision of the non-modular analysis.
@inproceedings{Stievenart2017Modular, booktitle = {BElgian-NEtherlands eVOLution seminar 2017 (BENEVOL)}, title = {Modular Static Analysis of Actor Programs}, keywords = {abstract interpretation, actors, static analysis, modular analysis}, author = {Sti{\'e}venart, Quentin and Nicolay, Jens and {De Roover}, Coen and {De Meuter}, Wolfgang}, year = {2017}, month = dec, day = {5}, language = {English}, url = {http://ansymore.uantwerpen.be/events/benevol2017} }
Incrementalizing Abstract Interpretation

N. Van Es, M. Vandercammen, and C. De Roover

CEUR Workshop Proceedings, 2017

Abs Bib

Interpretation Position Paper Noah Van Es, Maarten Vandercammen, Coen De Roover Software Languages Lab – Vrije Universiteit Brussel – Brussels, Belgium noahves, mvdcamme, cderoove@vub.ac.be Abstract—A powerful approach to design static analysers is abstract interpretation, which reasons over an approximation of the program’s behaviour. The Abstracting Abstract Machines (AAM) technique, introduced by Van Horn & Might, presents a systematic approach to derive abstract interpreters. However, it is often not useable in the development and evolution of large- scale applications, as with the current state-of-the-art, an AAM analysis can not incrementally update its results upon changes in the program. That is, whenever minor modiﬁcations occur in the program’s source code, one needs to recompute the entire AAM analysis from scratch, which can easily get time-consuming. We therefore propose an incremental approach to abstract interpretation, more precisely the AAM technique. That is, we modify the technique so that the result of an AAM analysis, the abstract state graph, can incrementally be updated following a change in the program’s source code. Our algorithm tracks dependencies between the nodes in the abstract syntax tree (AST) of the program and the transitions in the abstract state graph to invalidate and recompute new transitions in the state graph upon a change in the AST. Our experiments using a set of Scheme micro-benchmarks reveal that in practice this approach is often limited, as only states that are identical in both state graphs are reusable. We therefore introduce an improvement to the original incremental algorithm, which we refer to as state adaptation. State adaptation also enables reusing states that are not identical, but similar. Both the original and improved algorithm are integrated and evaluated in the Scala- AM framework. Our current implementations already show good results in terms of incremental efﬁciency, although more optimization is required to achieve actual gains in run time performance with our approaches.
@article{VanEs2017Incrementalizing, title = {Incrementalizing Abstract Interpretation}, journal = {CEUR Workshop Proceedings}, year = {2017}, volume = {2047}, pages = {31-35}, author = {Van Es, N. and Vandercammen, M. and De Roover, C.} }
STRAF: A Scala Framework for Experiments in Trace-Based JIT Compilation

Maarten Vandercammen, Quentin Stiévenart, Wolfgang De Meuter, and 1 more author

In Grand Timely Topics in Software Engineering (GTTSE), 2017

Abs DOI Bib PDF

We introduce straf, a Scala framework for recording and optimizing execution traces of an interpreter it is composed with. For interpreters that satisfy the requirements detailed in this paper, this composition requires but a small eﬀort from the implementer to result in a trace-based JIT compiler. We describe the framework, and illustrate its composition with a Scheme interpreter that satisﬁes the aforementioned requirements. We benchmark the resulting trace-based JIT compiler on a set of Scheme programs. Finally, we implement an optimization to demonstrate that straf enables further experimentation in the domain.
@incollection{Vandercammen2017STRAF, title = {STRAF: A Scala Framework for Experiments in Trace-Based JIT Compilation}, isbn = {9783319600741}, issn = {1611-3349}, url = {http://dx.doi.org/10.1007/978-3-319-60074-1_10}, doi = {10.1007/978-3-319-60074-1_10}, booktitle = {Grand Timely Topics in Software Engineering (GTTSE)}, publisher = {Springer International Publishing}, author = {Vandercammen, Maarten and Stiévenart, Quentin and De Meuter, Wolfgang and De Roover, Coen}, year = {2017}, pages = {223–234} }
Untangling Source Code Changes Using Program Slicing

Ward Muylaert and Coen De Roover

In BElgian-NEtherlands eVOLution seminar 2017 (BENEVOL), Dec 2017

Abs Bib

Version control systems (VCS) are widely used to manage the history of code bases. These histories in turn provide opportunities for research. Researchers expect the commits in these version control systems to be atomic. That is, each commit performs one task. This is however not always the case. To remedy this, we propose a commit untangling technique using program slicing. In particular, we posit that all related changes are part of the same program slice. To do so, we perform program slicing on changes . Preliminary results using intra-procedural slicing have proven to be encouraging. We are currently working on expanding our work to be inter-procedural.
@inproceedings{Muylaert2017Untangling, booktitle = {BElgian-NEtherlands eVOLution seminar 2017 (BENEVOL)}, title = {Untangling Source Code Changes Using Program Slicing}, keywords = {program slicing, program dependence graph, java, tinypdg, changenodes, commits}, author = {Muylaert, Ward and {De Roover}, Coen}, year = {2017}, month = dec, day = {5}, language = {English}, pages = {36--38}, url = {http://ansymore.uantwerpen.be/events/benevol2017} }

2016

Improving trace-based JIT optimisation using whole-program information

Maarten Vandercammen and Coen De Roover

In Proceedings of the 8th International Workshop on Virtual Machines and Intermediate Languages (VMIL), Oct 2016

Abs DOI Bib PDF

Trace-based just-in-time compilers use program analyses to optimise execution traces. These analyses are limited in scope to the parts of the program that have been traced. In this posi- tion paper, we conjecture that trace optimisations can beneﬁt from extending the scope of their enabling analyses beyond these traces to the set of possible future execution states of the program. This by incorporating a static analysis which, however, necessarily over-approximates this set. We therefore propose to continuously reﬁne the set of future states com- puted by an initial, ahead-of-time analysis using run-time in- formation about the current execution state of the program. Additional static analyses launched at run time could further reﬁne the information about the future of the current and all possible states. We expect that the resulting, hybrid program view of static and dynamic information may enable additional optimisations on collected traces and that these optimisations may overcome the computational overhead of keeping the view up-to-date.
@inproceedings{Vandercammen2016Improving, series = {SPLASH ’16}, title = {Improving trace-based JIT optimisation using whole-program information}, url = {http://dx.doi.org/10.1145/2998415.2998418}, doi = {10.1145/2998415.2998418}, booktitle = {Proceedings of the 8th International Workshop on Virtual Machines and Intermediate Languages (VMIL)}, publisher = {ACM}, author = {Vandercammen, Maarten and De Roover, Coen}, year = {2016}, month = oct, pages = {16–23}, collection = {SPLASH ’16} }
Static Detection of User-specified Security Vulnerabilities in Client-side JavaScript

Jens Nicolay, Valentijn Spruyt, and Coen De Roover

In Proceedings of the 2016 ACM Workshop on Programming Languages and Analysis for Security (PLAS), Oct 2016

Abs DOI Bib PDF

interpretation is a theory that oﬀers a solution to the problem of costly or un- computable runtime properties [6]. Although the concrete semantics of a non-trivial program are not computable with ﬁnite resources, abstract interpretation nevertheless oﬀers a framework for getting useful answers to non-trivial ques- tions about programs. The answers we obtain from abstract interpretation will necessarily be approximations due to the undecidability of the questions asked. In the context of this paper the results of ﬂow analysis must conservatively approximate the control ﬂow and value ﬂow of programs, erring on the safe side in order to remain faithful to the original semantics. For example, if during concrete interpretation a call site invokes a particular func- tion, the analysis must reﬂect this possibility, but the anal- ysis may be imprecise in the sense that it overestimates the set of called functions at call sites. The default abstract semantics for JS-QL equips JIPDA’s abstract machine with a set lattice containing primitive types and pointers, and with monovariant object allocation (i.e., based on the syntactic allocation site). 3. THE JS-QL QUERY LANGUAGE JS-QL, short for JavaScript Query Language, is a lan- guage for expressing diﬀerent kinds of application-speciﬁc and user-deﬁned security vulnerabilities. To this end, the language specializes in expressing queries matching se- quences of program states in the ﬂow graph by making using of regular path expressions [8, 26]. Regular path expressions describe paths in a graph in a syntax similar to regular ex- pressions. It is important that exploring and accessing infor- mation in a ﬂow graph happens in an expressive yet readable way, as such graphs might be complex to understand. We are convinced that regular path expressions enable users to write clean and understandable queries. We ﬁrst discuss the design of JS-QL (Section 3.1), and then present an overview of the language (Section 3.2).
@inproceedings{Nicolay2016Static, series = {CCS′16}, title = {Static Detection of User-specified Security Vulnerabilities in Client-side JavaScript}, url = {http://dx.doi.org/10.1145/2993600.2993612}, doi = {10.1145/2993600.2993612}, booktitle = {Proceedings of the 2016 ACM Workshop on Programming Languages and Analysis for Security (PLAS)}, publisher = {ACM}, author = {Nicolay, Jens and Spruyt, Valentijn and De Roover, Coen}, year = {2016}, month = oct, pages = {3–13}, collection = {CCS′16} }

2015

A formal foundation for trace-based JIT compilers

Maarten Vandercammen, Jens Nicolay, Stefan Marr, and 3 more authors

In Proceedings of the 13th International Workshop on Dynamic Analysis (WODA), Oct 2015

Abs DOI Bib PDF

Trace-based JIT compilers identify frequently executed pro- gram paths at run-time and subsequently record, compile and optimize their execution. In order to improve the per- formance of the generated machine instructions, JIT com- pilers heavily rely on dynamic analysis of the code. Existing work treats the components of a JIT compiler as a monolithic whole, tied to particular execution semantics. We propose a formal framework that facilitates the design and implemen- tation of a tracing JIT compiler and its accompanying dy- namic analyses by decoupling the tracing, optimization, and interpretation processes. This results in a framework that is more conﬁgurable and extensible than existing formal trac- ing models. We formalize the tracer and interpreter as two abstract state machines that communicate through a mini- mal, well-deﬁned interface. Developing a tracing JIT com- piler becomes possible for arbitrary interpreters that imple- ment this interface. The abstract machines also provide the necessary hooks to plug in custom analyses and optimiza- tions.
@inproceedings{Vandercammen2015formal, series = {SPLASH ’15}, title = {A formal foundation for trace-based JIT compilers}, url = {http://dx.doi.org/10.1145/2823363.2823369}, doi = {10.1145/2823363.2823369}, booktitle = {Proceedings of the 13th International Workshop on Dynamic Analysis (WODA)}, publisher = {ACM}, author = {Vandercammen, Maarten and Nicolay, Jens and Marr, Stefan and De Koster, Joeri and D’Hondt, Theo and De Roover, Coen}, year = {2015}, month = oct, pages = {25–30}, collection = {SPLASH ’15} }

2014

Run-time Validation of Behavioral Adaptations

Nicolás Cardozo, Laurent Christophe, Coen De Roover, and 1 more author

In Proceedings of 6th International Workshop on Context-Oriented Programming - COP′14 (COP), 2014

Abs DOI Bib PDF

Context-oriented programming enables the composition of behavioral adaptations into a running software system. Be- havioral adaptations provide the most appropriate behavior of a system when their contexts are activated or deactivated, according to the situations at hand in the system’s execu- tion environment. Behavioral adaptations can be deﬁned by third-party vendors or even be acquired at run time. As the systems grows in complexity it becomes increasingly diﬃcult to reason about every possible runtime adaptation. There- fore, behavioral adaptations that lead to erroneous states or compromise the system’s security might be diﬃcult to detect statically. To prevent such undesired behavioral adaptations from happening, we introduce a run-time correctness veriﬁ- cation approach. Our approach uses a symbolic execution engine to reason about the reachable states of the system, whenever contexts are activated or deactivated. Context ac- tivation and deactivation requests are allowed depending on the presence of erroneous states within reachable states. Our approach is a step forward to ensure the run-time correctness of software systems that adapt their behavior dynamically.
@inproceedings{Cardozo2014Run, series = {COP′14}, title = {Run-time Validation of Behavioral Adaptations}, url = {http://dx.doi.org/10.1145/2637066.2637071}, doi = {10.1145/2637066.2637071}, booktitle = {Proceedings of 6th International Workshop on Context-Oriented Programming - COP′14 (COP)}, publisher = {ACM Press}, author = {Cardozo, Nicolás and Christophe, Laurent and De Roover, Coen and De Meuter, Wolfgang}, year = {2014}, pages = {1–6}, collection = {COP′14} }

2011

Language and middleware support for dynamism in wireless sensor and actuator network applications

Nelson Matthys, Sam Michiels, Wouter Joosen, and 4 more authors

In Proceedings of the 6th International Workshop on Middleware Tools, Services and Run-time Support for Networked Embedded Systems (MidSens), Dec 2011

Abs DOI Bib PDF

Advances in wireless sensing and actuation technology allow for reasonable amounts of application logic to be embedded inside wireless sensor networks. Such applications are more autonomous but are signiﬁcantly more complex to program and manage. First, in-network adaptations need to be sup- ported due to the long-lived nature of the network. Second, the intrinsic dynamism of the network challenges how appli- cations interact with each other. Third, as applications be- come more complex, coordinating their interactions becomes more diﬃcult. This paper explores how the integration of an event-based component middleware, a policy-based manage- ment system, and a domain-speciﬁc coordination language gives rise to comprehensive support for developing and man- aging this new breed of applications.
@inproceedings{Matthys2011Language, series = {Middleware ’11}, title = {Language and middleware support for dynamism in wireless sensor and actuator network applications}, url = {http://dx.doi.org/10.1145/2090296.2090298}, doi = {10.1145/2090296.2090298}, booktitle = {Proceedings of the 6th International Workshop on Middleware Tools, Services and Run-time Support for Networked Embedded Systems (MidSens)}, publisher = {ACM}, author = {Matthys, Nelson and Michiels, Sam and Joosen, Wouter and Scholliers, Christophe and De Roover, Coen and Amerijckx, Wouter and D’Hondt, Theo}, year = {2011}, month = dec, pages = {1–6}, collection = {Middleware ’11} }

2010

Generation and composition of corrective actions to code design problems with Heal

Sergio Castro, Andy Kellens, Coen De Roover, and 1 more author

9th BElgian-NEtherlands EVOLution Workshop (BENEVOL), 2010

Abs Bib

Maintaining consistency between design and implementation is a fundamental issue in software evolution. Although existing tools and techniques provide support for correcting inconsistencies, they target generally-applicable design rules. Unfortunately, in addition to these common design rules, any software system has an abundance of custom design rules that are very specific to the system at hand. For such custom design rules, verification and correction are often left to the developer or require a considerable investment in the implementation of specific verification and correction meta-programs. HEAL is a framework that alleviates the problem of diagnosing and correcting violations of custom design rules in code. It supports the implementation and automatic inference of corrective actions (i.e., program transformations that may solve a detected design inconsistency. Using an abductive logic reasoner, HEAL infers these corrective actions from the design rules themselves and the code over which these rules are verified. In previous work we showed how simple solutions are generated from a repository of corrective actions to low- level structural problems. In this paper, we extend our previous work by showing how multiple solutions affecting the same source code element can be composed, allowing for the correction of complex design inconsistencies.
@article{Castro2010Generation, title = {Generation and composition of corrective actions to code design problems with Heal}, keywords = {Abductive reasoning, IntensiVE}, author = {Castro, Sergio and Kellens, Andy and {De Roover}, Coen and Mens, Kim}, year = {2010}, language = {English}, journal = {9th BElgian-NEtherlands EVOLution Workshop (BENEVOL)} }

2009

Language-Shifting Objects in Inter-language Interoperability: an exploration using JavaConnect

Johan Brichau and Coen De Roover

In Proceedings of the International Workshop on Smalltalk Technologies (IWST 2009), 2009

Abs Bib PDF

Foreign-function interfaces enable programs in a host lan- guage to interoperate with programs written in another lan- guage and vice-versa. Two languages that feature such an interface to a common language can even interoperate by means of this common intermediate language. Smalltalk and Java, for example, both offer an interface to C and can there- fore interoperate through a connection of these interfaces. However, the resulting interactions will need to occur at the level of abstraction offered by the (low-level) C interfaces, although both Java and Smalltalk are object-oriented lan- guages. In this paper, we describe how the dynamic and reﬂective facilities of the Smalltalk language permits us to raise the level of abstraction of these inter-language interac- tions to seamless message passing between objects. In ad- dition, we introduce and explore the concept of language shifting objects where Java objects are not only represented in Smalltalk but can partially or completely migrate from Java to Smalltalk. Language-shifting effectively migrates Java methods to Smalltalk methods such that original Java objects can end up “living” in the Smalltalk environment without needing a connection to their originating Java en- vironment.
@inproceedings{Brichau2009LanguageShifting, title = {Language-Shifting Objects in Inter-language Interoperability: an exploration using JavaConnect}, author = {Brichau, Johan and {De Roover}, Coen}, booktitle = {Proceedings of the International Workshop on Smalltalk Technologies (IWST 2009)}, address = {Brest, France}, year = {2009}, }
Language-shifting objects from Java to Smalltalk: an exploration using JavaConnect

Johan Brichau and Coen De Roover

In Proceedings of the International Workshop on Smalltalk Technologies, Aug 2009

Abs DOI Bib

Foreign-function interfaces enable programs in a host lan- guage to interoperate with programs written in another lan- guage and vice-versa. Two languages that feature such an interface to a common language can even interoperate by means of this common intermediate language. Smalltalk and Java, for example, both offer an interface to C and can there- fore interoperate through a connection of these interfaces. However, the resulting interactions will need to occur at the level of abstraction offered by the (low-level) C interfaces, although both Java and Smalltalk are object-oriented lan- guages. In this paper, we describe how the dynamic and reﬂective facilities of the Smalltalk language permits us to raise the level of abstraction of these inter-language interac- tions to seamless message passing between objects. In ad- dition, we introduce and explore the concept of language shifting objects where Java objects are not only represented in Smalltalk but can partially or completely migrate from Java to Smalltalk. Language-shifting effectively migrates Java methods to Smalltalk methods such that original Java objects can end up “living” in the Smalltalk environment without needing a connection to their originating Java en- vironment.
@inproceedings{Brichau2009Language, series = {IWST ’09}, title = {Language-shifting objects from Java to Smalltalk: an exploration using JavaConnect}, url = {http://dx.doi.org/10.1145/1735935.1735956}, doi = {10.1145/1735935.1735956}, booktitle = {Proceedings of the International Workshop on Smalltalk Technologies}, publisher = {ACM}, author = {Brichau, Johan and De Roover, Coen}, year = {2009}, month = aug, pages = {120–125}, collection = {IWST ’09} }

2008

Example-based Program Querying

Andy Kellens, Johan Brichau, and Coen De Roover

In International Workshop on Query Technologies and Applications for Program Comprehension (QTAPC), Jun 2008

Abs Bib

Program query languages are an essential component of program analysis and manipulation systems. In each such system, a query identifies the source-code parts of interest by reasoning over a program representation that is dedicated to the intent of the system (e.g. call-graphs to detect behavioral flaws, abstract syntax trees for refactorings, concrete source code to verify programming conventions,etc.). In order to detect a wide variety of such patterns of interest, or more importantly, to detect patterns that require a combination of such program representations, developers must understand all the different applicable representations and techniques. We therefore present a logic based language that allows the program’s implementation to be queried using concrete source code templates that are matched against a combination of structural and behavioral program representations. These representations include call-graphs, points-to analysis results and abstract syntax trees that are uniformly composed through a customizable unification procedure. The result of our approach is that developers can detect patterns in the queried program using source code excerpts (embedded in logic queries) which act as prototypical samples of the structure and behavior they intend to match.
@inproceedings{Kellens2008Example, booktitle = {International Workshop on Query Technologies and Applications for Program Comprehension (QTAPC)}, title = {Example-based Program Querying}, keywords = {Program comprehension, Program querying}, author = {Kellens, Andy and Brichau, Johan and {De Roover}, Coen}, year = {2008}, month = jun, day = {10}, language = {English} }

Dissertations

2009

A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs

Coen De Roover

PhD Dissertation, Vrije Universiteit Brussel, 2009

Abs Bib PDF

The growing number of tools for detecting user-specified software patterns is testament to their valuable applications throughout the development process. In these applications, user-specified software patterns describe code that exhibits characteristics of interest. For instance, violations of the protocol an API expects to be adhered to. Logic formulas can be used as expressive and descriptive pattern specifications. This merely requires reifying the program under investigation such that variables can range over its elements. Executing a proof procedure will establish whether program elements exhibit the characteristics specified in a formula. However, we have observed that such formulas become convoluted and operational in nature when developers attempt to ensure all instances of a pattern are recalled. As the behavioral characteristics of a pattern can be implemented in different ways, the corresponding formula either has to enumerate each implementation variant or describe the machine-verifiable behavior shared by these variants. The former formulas are relatively descriptive, but only recall the implementation variants that are enumerated. The latter formulas recall all implementations of the specified behavior, but do so by quantifying over information about the program’s behavior. This exposes developers to the intricate details of the program analyses that compute this information. We have reconciled both approaches by embedding source code excerpts in logic formulas. These excerpts exemplify the prototypical implementation of a pattern’s characteristics —thus ensuring the resulting specifications are descriptive. They are specified in the concrete syntax of the base program augmented with logic variables. To ensure that all implementation variants are recalled, these excerpts are matched against behavioral program information according to multiple matching strategies that vary in leniency. Each match is quantified by the extent to which it exhibits the specified characteristics. The smaller this extent, the more likely the match is a false positive. This establishes a ranking which facilitates assessing a large amount of matches. A logic of quantified truth provides the theoretical foundation for this ranking. Unique to our matching process is that it incorporates whole-program analyses in its comparison of individual program elements. A semantic analysis ensures correctness. To compare an unqualified and fully qualified type, for instance, a semantic analysis takes the import declarations into account of the compilation units in which they reside. A points-to analysis increases the amount of implementation variants that are recalled. When expressions are compared, for instance, syntactic deviations are allowed as long as they may evaluate to the same object at run-time. The resulting example-driven approach to pattern detection recalls the implicit implementation variants (i.e. those that are implied by the semantics of the programming language) of a machine-verifiable characteristic specified as a code excerpt that exemplifies its prototypical implementation.
@phdthesis{DeRoover2009Logic, title = {A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs}, keywords = {logic programming, program analysis, software patterns, pattern detection}, author = {{De Roover}, Coen}, year = {2009}, language = {English}, isbn = {9789054876212}, publisher = {VUB Press}, school = {Vrije Universiteit Brussel} }

2004

Incorporating Dynamic Analysis and Approximate Reasoning in Declarative Meta-Programming to Support Software Re-engineering

Coen De Roover

Licentiate's Thesis, Vrije Universiteit Brussel, 2004

Abs Bib PDF

Software re-engineering is a complex process in which a maintainer is confronted with the challenging task of understanding the design of an existing application of which the documentation is often non-existent or no longer up-to-date. To support the software engineer in this precarious undertaking, many design recovery tools based upon declarative meta-programming techniques have been proposed, but most of them are only able to reason about a program’s structural architecture instead of about the exhibited run-time behaviour. This document explores how behavioural analysis can complement structural source code analysis in the detection of software patterns in the broadest sense. Furthermore, interesting software patterns often describe inherently vague concepts which cannot be expressed efﬁciently in classical logic programming languages. Many software patterns are in addition described by such overly idealised logic rules that real-life variations on the implementation of these abstract patterns can no longer be detected. In this dissertation, we will therefore also study the use of approximate rea- soning techniques to overcome these common problems. ii
@mastersthesis{DeRoover2004Incorporating, title = {Incorporating Dynamic Analysis and Approximate Reasoning in Declarative Meta-Programming to Support Software Re-engineering}, author = {{De Roover}, Coen}, year = {2004}, school = {Vrije Universiteit Brussel}, }

Books

2023

Software Ecosystems: Tooling and Analytics

Tom Mens, Coen De Roover, and Anthony Cleve

2023

Abs DOI Bib

Highlights advances in technological domains such as collaborative SWE, library reuse, sentiment analysis, and ML Covers topics related to SW ecosystem mining, analysis, modeling, evolution, and automation Aimed at researchers and practitioners interested in analyses of, and tooling for, SW ecosystems.
@book{Mens2023Software, title = {Software Ecosystems: Tooling and Analytics}, isbn = {9783031360602}, url = {http://dx.doi.org/10.1007/978-3-031-36060-2}, doi = {10.1007/978-3-031-36060-2}, publisher = {Springer International Publishing}, editor = {Mens, Tom and De Roover, Coen and Cleve, Anthony}, author = {Mens, Tom and De Roover, Coen and Cleve, Anthony}, year = {2023} }

Book Chapters

2023

An Introduction to Software Ecosystems

Tom Mens and Coen De Roover

In Software Ecosystems: Tooling and Analytics, 2023

Abs DOI Bib

This chapter defines and presents the kinds of software ecosystems that are targeted in this book. The focus is on the development, tooling, and analytics aspects of “software ecosystems,” i.e., communities of software developers and the interconnected software components (e.g., projects, libraries, packages, repositories, plug-ins, apps) they are developing and maintaining. The technical and social dependencies between these developers and software components form a socio-technical dependency network, and the dynamics of this network change over time. We classify and provide several examples of such ecosystems, many of which will be explored in further detail in the subsequent chapters of the book. The chapter also introduces and clarifies the relevant terms needed to understand and analyze these ecosystems, as well as the techniques and research methods that can be used to analyze different aspects of these ecosystems.
@incollection{Mens2023Introduction, title = {An Introduction to Software Ecosystems}, isbn = {9783031360602}, url = {http://dx.doi.org/10.1007/978-3-031-36060-2_1}, doi = {10.1007/978-3-031-36060-2_1}, booktitle = {Software Ecosystems: Tooling and Analytics}, publisher = {Springer International Publishing}, author = {Mens, Tom and Roover, Coen De}, year = {2023}, pages = {1–29} }
Infrastructure-as-Code Ecosystems

Ruben Opdebeeck, Ahmed Zerouali, and Coen De Roover

In Software Ecosystems: Tooling and Analytics, 2023

Abs DOI Bib

Infrastructure as Code (IaC) is the practice of automating the provisioning, configuration, and orchestration of systems onto which software is deployed through scripts in domain-specific languages. With the increasing importance of reliable and repeatable deployments, ecosystems are emerging around online repositories of reusable IaC assets. In this chapter, we study two such ecosystems in detail: the one forming around the Docker Hub repository of reusable Docker images and the one forming around the Ansible Galaxy repository of reusable Ansible roles. We start with an introduction to Docker, the most popular container management tool, and Ansible, the most popular configuration management tool. Although both tools are used to configure machines onto which applications are deployed, they differ fundamentally in the means through which this is achieved. Next, we discuss the Docker Hub and Ansible Galaxy online repositories for reusable Docker images and Ansible roles. Having introduced these emerging ecosystems, we highlight a number of approaches taken by researchers studying them. Subsequently, we survey the state of the art in research on the practices followed by their contributors and users, ranging from the versioning of releases and keeping dependencies up to date to detecting bugs. We conclude with the challenges that researchers face when analyzing these ecosystems.
@incollection{Opdebeeck2023Infrastructure, title = {Infrastructure-as-Code Ecosystems}, isbn = {9783031360602}, url = {http://dx.doi.org/10.1007/978-3-031-36060-2_9}, doi = {10.1007/978-3-031-36060-2_9}, booktitle = {Software Ecosystems: Tooling and Analytics}, publisher = {Springer International Publishing}, author = {Opdebeeck, Ruben and Zerouali, Ahmed and Roover, Coen De}, year = {2023}, pages = {215–245} }