@incollection{dyer15:boa-book, author = {Dyer, Robert and Nguyen, Hoan Anh and Rajan, Hridesh and Nguyen, Tien N.}, title = {{Boa}: an Enabling Language and Infrastructure for Ultra-large Scale {MSR} Studies}, editor = {Bird, Christian and Menzies, Tim and Zimmermann, Thomas}, booktitle = {The Art and Science of Analyzing Software Data}, pages = {593-621}, date = {2015-09-15}, publisher = {Morgan-Kaufmann}, address = {Waltham, MA}, doi = {10.1016/C2012-0-07289-4}, abstract = {Mining software repositories (MSR) on a large scale is important for more generalizable research results. Large collections of software artifacts are openly available (e.g., SourceForge has more than 350,000 projects, GitHub has more than 10 million projects, and Google Code has more than 250,000 projects), but capitalizing on this data is extremely difficult. This chapter serves as a reference guide for Boa, a language and infrastructure designed to decrease the barrier to entry for ultra-large-scale MSR studies. Boa consists of a domain-specific language, its compiler, a dataset that contains almost 700,000 open source projects as of this writing, a back end based on MapReduce to effectively analyze this dataset, and a Web-based front end for writing MSR programs. This chapter describes how researchers and software practitioners can start using this resource.}, } @inproceedings{flint26:icpc, author = {Flint, Samuel W. and Dyer, Robert and Sharif, Bonita}, title = {Do Developers Read Type Information? {An} Eye-Tracking Study}, date = {2026-04-12}, booktitle = {Proceedings of the IEEE International Conference on Program Comprehension}, pages = {{73-84}}, series = {{ICPC}}, location = {Rio de Janeiro, Brazil}, abstract = {Statically-annotated types have been shown to aid developers in a number of programming tasks, and this benefit holds true even when static type checking is not used. It is hypothesized that this is because developers use type annotations as in-code documentation. In this study, we aim to provide evidence that developers use type annotations as in-code documentation. Understanding this hypothesized use will help to understand how, and in what contexts, developers use type information; additionally, it may help to design better development tools and inform educational decisions. To provide this evidence, we conduct an eye tracking study with 26 undergraduate students to determine if they read type annotations during code comprehension and bug localization in the TypeScript language. We found that developers do not appear to gaze directly at lines containing type annotations or type declarations more often when they are present, in either code summarization or bug localization tasks. The results have implications for tool builders to improve the availability of type information, the development community to build good standards for use of type annotations, and education to enforce deliberate teaching of reading patterns.}, doi = {10.1145/3794763.3794800}, } @inproceedings{abdelmadjid25:pytest, author = {Abdelmadjid, Idriss and Dyer, Robert}, title = {{pyMethods2Test}: A Dataset of {Python} Tests Mapped to Focal Methods}, date = {2025-04-29}, pages = {{846-850}}, booktitle = {Proceedings of the International Conference on Mining Software Repositories}, series = {{MSR}}, address = {Ottawa, Canada}, abstract = {Python is one of the fastest-growing programming languages and currently ranks as the top language in many lists, even recently overtaking JavaScript as the top language on GitHub. Given its importance in data science and machine learning, it is imperative to be able to effectively train LLMs to generate good unit test cases for Python code. This motivates the need for a large dataset to provide training and testing data. To date, while other large datasets exist for languages like Java, none publicly exist for Python. Python poses difficult challenges in generating such a dataset, due to its less rigid naming requirements. In this work, we consider two commonly used Python unit testing frameworks: Pytest and unittest. We analyze a large corpus of over 88K open-source GitHub projects utilizing these testing frameworks. Using a carefully designed set of heuristics, we are able to locate over 22 million test methods. We then analyze the test and non-test code and map individual unit tests to the focal method being tested. This provides an explicit traceability link from the test to the tested method. Our pyMethods2Test dataset contains over 2 million of these focal method mappings, as well as the ability to generate useful context for input to LLMs. The pyMethods2Test dataset is publicly available on Zenodo at: https://doi.org/10.5281/zenodo.14264519}, doi = {10.1109/MSR66628.2025.00123}, } @inproceedings{batole:llm-agents, author = {Batole, Fraol and OBrien, David and Nguyen, Tien N. and Dyer, Robert and Rajan, Hridesh}, title = {An {LLM}-Based Agent-Oriented Approach for Automated Code Design Issue Localization}, date = {2025-05-01}, booktitle = {Proceedings of the IEEE/ACM International Conference on Software Engineering Companion}, pages = {{1320-1332}}, series = {{ICSE}}, address = {Ottawa, Canada}, abstract = {Maintaining software design quality is crucial for the long-term maintainability and evolution of systems. However, design issues such as poor modularity and excessive complexity often emerge as codebases grow. Developers rely on external tools, such as program analysis techniques, to identify such issues. This work investigates an automated approach for analyzing and localizing design issues using Large Language Models (LLMs). Large language models have demonstrated significant performance on coding tasks, but directly leveraging them for design issue localization is challenging. Large codebases exceed typical LLM context windows, and program analysis tool outputs in non-textual modalities (e.g., graphs or interactive visualizations) are incompatible with LLMs' natural language inputs. To address these challenges, we propose LOCALIZEAGENT, a novel multi-agent framework for effective design issue localization. LOCALIZEAGENT integrates specialized agents that (1) analyze code to identify potential code design issues, (2) transform program analysis outputs into abstraction-aware LLM-friendly natural language summaries, (3) generate context-aware prompts tailored to specific refactoring types, and (4) leverage LLMs to locate and rank the localized issues based on their relevance. Our evaluation using diverse real-world codebases demonstrates significant improvements over baseline approaches, with LOCALIZEAGENT achieving 138\%, 166\%, and 206\% relative improvements in exact match accuracy for localizing information hiding, complexity, and modularity issues, respectively.}, doi = {10.1109/ICSE55347.2025.00100}, } @inproceedings{obrien24:sugars, author = {OBrien, David and Dyer, Robert and Nguyen, Tien N. and Rajan, Hridesh}, title = {Data-Driven Evidence-Based Syntactic Sugar Design}, date = {2024-04-17}, booktitle = {Proceedings of the 46th IEEE/ACM International Conference on Software Engineering}, doi = {10.1145/3597503.3639580}, articleno = {203}, pages = {1-12}, series = {{ICSE}}, address = {Lisbon, Portugal}, abstract = {Programming languages are essential tools for developers, and their evolution plays a crucial role in supporting the activities of its developers. One instance of programming language evolution is the introduction of syntactic sugars, which are additional syntax elements that provide alternative, more readable code constructs. However, the process of designing and evolving a programming language has traditionally been guided by anecdotal experiences and intuition. Recent advances in tools and methodologies for mining open-source repositories have enabled developers to make datadriven software engineering decisions. In light of this, this paper proposes an approach for motivating data-driven programming evolution by applying frequent subgraph mining techniques to a large dataset of 166,827,154 open-source Java methods. The dataset is mined by generalizing Java control-flow graphs to capture broad programming language usages and instances of duplication. Frequent subgraphs are then extracted to identify potentially impactful opportunities for new syntactic sugars. Our diverse results demonstrate the benefits of the proposed technique by identifying new syntactic sugars involving a variety of programming constructs that could be implemented in Java, thus simplifying frequent code idioms. This approach can potentially provide valuable insights for Java language designers, and serve as a proof-of-concept for data-driven programming language evolution.}, } @inproceedings{keshk23:method-chaining, author = {Keshk, Ali M. and Dyer, Robert}, title = {Method Chaining Redux: An Empirical Study of Method Chaining in {Java}, {Kotlin}, and {Python}}, date = {2023-05-15}, booktitle = {Proceedings of the 20th International Conference on Mining Software Repositories}, pages = {546-557}, series = {{MSR}}, doi = {10.1109/MSR59073.2023.00080}, address = {Melbourne, Australia}, abstract = {There are possible benefits and drawbacks to chaining methods together, as is often done in fluent APIs. A prior study investigated how Java developers chain methods in over 2.7k open-source projects. That study observed, for the dataset analyzed, that the use of method chaining in Java is popular and seems to be increasing over time. That study however was limited to a smaller sample of Java projects, and it is also not clear if the results generalize to other languages. In this work, we first replicate the prior results by building a similar dataset and our own analysis scripts. We then extend those results by analyzing a much larger dataset of 89k Java projects and generalizing to other programming languages by analyzing 26k Kotlin projects and 98k Python projects. The results show chaining is more popular in Java and Kotlin than Python, chaining use in Kotlin is not growing, and Python sees more use in non-testing code.}, } @inproceedings{dyer22:predominant-paradigms, author = {Dyer, Robert and Chauhan, Jigyasa}, title = {An Exploratory Study on the Predominant Programming Paradigms in {Python} Code}, date = {2022-11-16}, isbn = {9781450394130}, publisher = {Association for Computing Machinery}, doi = {10.1145/3540250.3549158}, booktitle = {Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering}, pages = {684-695}, series = {{ESEC/FSE}}, address = {Singapore}, abstract = {Python is a multi-paradigm programming language that fully supports object-oriented (OO) programming. The language allows writing code in a non-procedural imperative manner, using procedures, using classes, or in a functional style. To date, no one has studied what paradigm(s), if any, are predominant in Python code and projects. In this work, we first define a technique to classify Python files into predominant paradigm(s). We then automate our approach and evaluate it against human judgements, showing over 80\% agreement. We then analyze over 100k open-source Python projects, automatically classifying each source file and investigating the paradigm distributions. The results indicate Python developers tend to heavily favor OO features. We also observed a positive correlation between OO and procedural paradigms and the size of the project. And despite few files or projects being predominantly functional, we still found many functional feature uses.}, } @inproceedings{flint21:time-pit, author = {Flint, Samuel W. and Chauhan, Jigyasa and Dyer, Robert}, booktitle = {Proceedings of the 18th International Conference on Mining Software Repositories}, title = {Escaping the Time Pit: Pitfalls and Guidelines for Using Time-Based {Git} Data}, date = {2021-05-17}, pages = {85-96}, series = {{MSR}}, address = {Madrid, Spain}, doi = {10.1109/MSR52588.2021.00022}, abstract = {Many software engineering research papers rely on time-based data (e.g., commit timestamps, issue report creation/update/close dates, release dates). Like most real-world data however, time-based data is often dirty. To date, there are no studies that quantify how frequently such data is used by the software engineering research community, or investigate sources of and quantify how often such data is dirty. Depending on the research task and method used, including such dirty data could affect the research results. This paper presents the first survey of papers that utilize time-based data, published in the Mining Software Repositories (MSR) conference series. Out of the 690 technical track and data papers published in MSR 2004--2020, we saw at least 35\% of papers utilized time-based data. We then used the Boa and Software Heritage infrastructures to help identify and quantify several sources of dirty commit timestamp data. Finally we provide guidelines/best practices for researchers utilizing time-based data from Git repositories.}, } @inproceedings{hung20:boa-views, author = {Hung, Che Shian and Dyer, Robert}, title = {{Boa} Views: Easy Modularization and Sharing of {MSR} Analyses}, date = {2020-06-29}, isbn = {9781450375177}, publisher = {Association for Computing Machinery}, doi = {10.1145/3379597.3387480}, booktitle = {Proceedings of the 17th International Conference on Mining Software Repositories}, pages = {147-157}, address = {Seoul, Republic of Korea}, series = {{MSR}}, abstract = {Mining Software Repositories (MSR) has recently seen a focus toward ultra-large-scale datasets. Several tools exist to support these efforts, such as the Boa language and infrastructure. While Boa has seen extensive use, in its current form it is not always possible to perform the entire analysis task within the infrastructure, often requiring some post-processing in another language. This limits end-to-end reproducibility and limits sharing/re-use of MSR queries. To address this problem, we use the notion of views from the relational database field and designed a query language and runtime infrastructure extension for Boa that we call materialized views. Materialized views provide output reuse to Boa users, so that the results of prior Boa queries can be easily reused by others. This allows for computing results not previously possible within Boa and provides for increased sharing and reuse of MSR queries. To evaluate views, we performed two partial reproductions of prior MSR studies utilizing Boa's dataset and infrastructure and compare our results to the prior studies. This shows the usability of the new infrastructure, allowing analyses in Boa that were not previously possible as well as providing a previously hand created gold dataset for identifier splitting as a reusable view for other MSR researchers. We also verified the caching behavior using the queries from one of the case studies. The results show that caching works as expected and can drastically improve runtime performance.}, } @inproceedings{sherman18:seclabs, author = {Sherman, Elena and Dyer, Robert}, title = {Software Engineering Collaboratories ({SEClabs}) and Collaboratories as a Service ({CaaS})}, date = {2018-11-06}, isbn = {9781450355735}, publisher = {Association for Computing Machinery}, doi = {10.1145/3236024.3264839}, booktitle = {Proceedings of the 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering}, pages = {760-764}, address = {Lake Buena Vista, FL, USA}, series = {{ESEC/FSE}}, abstract = {Novel research ideas require strong evaluations. Modern software engineering research evaluation typically requires a set of benchmark programs. Open source software repositories have provided a great opportunity for researchers to find such programs for use in their evaluations. Many tools/techniques have been developed to help automate the curation of open source software. There has also been encouragement for researchers to provide their research artifacts so that other researchers can easily reproduce the results. We argue that these two trends (i.e., curating open source software for research evaluation and the providing of research artifacts) drive the need for Software Engineer Collaboratories (SEClabs). We envision research communities coming together to create SEClab instances, where research artifacts can be made publicly available to other researchers. The community can then vet such artifacts and make them available as a service, thus turning the collaboratory into a Collaboratory as a Service (CaaS). If our vision is realized, the speed and transparency of research will drastically increase.}, } @inproceedings{shekarforoush17:classifying-commits, author = {Shekarforoush, SeyedHamid and Green, Robert and Dyer, Robert}, booktitle = {International Joint Conference on Neural Networks}, series = {{IJCNN}}, title = {Classifying commit messages: A case study in resampling techniques}, date = {2017-05-18}, pages = {1273-1280}, address = {Anchorage, AK, USA}, doi = {10.1109/IJCNN.2017.7965999}, abstract = {In practice, there are a variety of real-world datasets that have an imbalanced nature where one of two classes dominates the data. These datasets are generally difficult to classify using machine learning algorithms as the skewed nature of the data has a significant impact on the training process. In order to combat this difficulty, many methods of under sampling and over sampling have been proposed in order to generate comparable data sets that are more easily classifiable. This study applies multiple resampling techniques to a set of commit messages that have been extracted from multiple Github and Sourceforge projects in order to answer the question, "Do developers discuss design?" This dataset is highly imbalanced with less than 15\% of all commit messages being classified as having to do with design. Results demonstrate that the combined use of resampling as coupled with various classification algorithms yields improvements in classification over the state-of-the-art by more than 10\% in terms of accuracy.}, } @inproceedings{rajan15:specinfer-collective, author = {Rajan, Hridesh and Nguyen, Tien N. and Leavens, Gary T. and Dyer, Robert}, booktitle = {Proceedings of the 37th International Conference on Software Engineering}, title = {Inferring Behavioral Specifications from Large-scale Repositories by Leveraging Collective Intelligence}, date = {2015-05-20}, volume = {2}, number = {}, series = {{ICSE}}, address = {Firenze, Italy}, pages = {579-582}, doi = {10.1109/ICSE.2015.339}, abstract = {Despite their proven benefits, useful, comprehensible, and efficiently checkable specifications are not widely available. This is primarily because writing useful, non-trivial specifications from scratch is too hard, time consuming, and requires expertise that is not broadly available. Furthermore, the lack of specifications for widely-used libraries and frameworks, caused by the high cost of writing specifications, tends to have a snowball effect. Core libraries lack specifications, which makes specifying applications that use them expensive. To contain the skyrocketing development and maintenance costs of high assurance systems, this self-perpetuating cycle must be broken. The labor cost of specifying programs can be significantly decreased via advances in specification inference and synthesis, and this has been attempted several times, but with limited success. We believe that practical specification inference and synthesis is an idea whose time has come. Fundamental breakthroughs in this area can be achieved by leveraging the collective intelligence available in software artifacts from millions of open source projects. Fine-grained access to such data sets has been unprecedented, but is now easily available. We identify research directions and report our preliminary results on advances in specification inference that can be had by using such data sets to infer specifications.}, } @inproceedings{bagherzadeh15:modular-reasoning-events, author = {Bagherzadeh, Mehdi and Dyer, Robert and Fernando, Rex D. and S\'{a}nchez, Jos\'{e} and Rajan, Hridesh}, title = {Modular Reasoning in the Presence of Event Subtyping}, date = {2015-03-18}, isbn = {9781450332491}, publisher = {Association for Computing Machinery}, doi = {10.1145/2724525.2724569}, booktitle = {Proceedings of the 14th International Conference on Modularity}, pages = {117-132}, address = {Fort Collins, CO, USA}, series = {{MODULARITY}}, abstract = {Separating crosscutting concerns while preserving modular reasoning is challenging. Type-based interfaces (event types) separate modularized crosscutting concerns (observers) and traditional object-oriented concerns (subjects). Event types paired with event specifications were shown to be effective in enabling modular reasoning about subjects and observers. Similar to class subtyping, organizing event types into subtyping hierarchies is beneficial. However, unrelated behaviors of observers and their arbitrary execution orders could cause unique, somewhat counterintuitive, reasoning challenges in the presence of event subtyping. These challenges threaten both tractability of reasoning and reuse of event types. This work makes three contributions. First, we pose and explain these challenges. Second, we propose an event-based calculus to show how these challenges can be overcome. Finally, we present modular reasoning rules of our technique and show its applicability to other event-based techniques.}, } @inproceedings{nguyen14:mining-preconditions, author = {Nguyen, Hoan Anh and Dyer, Robert and Nguyen, Tien N. and Rajan, Hridesh}, title = {Mining Preconditions of {APIs} in Large-Scale Code Corpus}, date = {2014-11-18}, isbn = {9781450330565}, publisher = {Association for Computing Machinery}, doi = {10.1145/2635868.2635924}, booktitle = {Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering}, pages = {166-177}, address = {Hong Kong, China}, series = {{FSE}}, abstract = {Modern software relies on existing application programming interfaces (APIs) from libraries. Formal specifications for the APIs enable many software engineering tasks as well as help developers correctly use them. In this work, we mine large-scale repositories of existing open-source software to derive potential preconditions for API methods. Our key idea is that APIs' preconditions would appear frequently in an ultra-large code corpus with a large number of API usages, while project-specific conditions will occur less frequently. First, we find all client methods invoking APIs. We then compute a control dependence relation from each call site and mine the potential conditions used to reach those call sites. We use these guard conditions as a starting point to automatically infer the preconditions for each API. We analyzed almost 120 million lines of code from SourceForge and Apache projects to infer preconditions for the standard Java Development Kit (JDK) library. The results show that our technique can achieve high accuracy with recall from 75-80\% and precision from 82-84\%. We also found 5 preconditions missing from human written specifications. They were all confirmed by a specification expert. In a user study, participants found 82\% of the mined preconditions as a good starting point for writing specifications. Using our mining result, we also built a benchmark of more than 4,000 precondition-related bugs.}, } @inproceedings{dyer14:java-feature-use, author = {Dyer, Robert and Rajan, Hridesh and Nguyen, Hoan Anh and Nguyen, Tien N.}, title = {Mining Billions of {AST} Nodes to Study Actual and Potential Usage of {Java} Language Features}, booktitle = {Proceedings of the 36th International Conference on Software Engineering}, date = {2014-06-03}, pages = {779-790}, series = {{ICSE}}, doi = {10.1145/2568225.2568295}, address = {Hyderabad, India}, abstract = {Programming languages evolve over time, adding additional language features to simplify common tasks and make the language easier to use. For example, the Java Language Specification has four editions and is currently drafting a fifth. While the addition of language features is driven by an assumed need by the community (often with direct requests for such features), there is little empirical evidence demonstrating how these new features are adopted by developers once released. In this paper, we analyze over 31k open-source Java projects representing over 9 million Java files, which when parsed contain over 18 billion AST nodes. We analyze this corpus to find uses of new Java language features over time. Our study gives interesting insights, such as: there are millions of places features could potentially be used but weren't; developers convert existing code to use new features; and we found thousands of instances of potential resource handling bugs.}, } @inproceedings{dyer13:boa, author = {Dyer, Robert and Nguyen, Hoan Anh and Rajan, Hridesh and Nguyen, Tien N.}, title = {{Boa}: A Language and Infrastructure for Analyzing Ultra-Large-Scale Software Repositories}, booktitle = {Proceedings of the 35th International Conference on Software Engineering}, date = {2013-05-23}, series = {{ICSE}}, pages = {422-431}, doi = {10.1109/ICSE.2013.6606588}, address = {San Francisco, CA}, abstract = {In today's software-centric world, ultra-large-scale software repositories, e.g. SourceForge (350,000+ projects), GitHub (250,000+ projects), and Google Code (250,000+ projects) are the new library of Alexandria. They contain an enormous corpus of software and information about software. Scientists and engineers alike are interested in analyzing this wealth of information both for curiosity as well as for testing important hypotheses. However, systematic extraction of relevant data from these repositories and analysis of such data for testing hypotheses is hard, and best left for mining software repository (MSR) experts! The goal of Boa, a domain-specific language and infrastructure described here, is to ease testing MSR-related hypotheses. We have implemented Boa and provide a web-based interface to Boa's infrastructure. Our evaluation demonstrates that Boa substantially reduces programming efforts, thus lowering the barrier to entry. We also see drastic improvements in scalability. Last but not least, reproducing an experiment conducted using Boa is just a matter of re-running small Boa programs provided by previous researchers.}, } @inproceedings{dyer13:task-fusion, author = {Dyer, Robert}, title = {Task Fusion: Improving Utilization of Multi-user Clusters}, booktitle = {Proceedings of the companion publication for conference on Systems, Programming, Languages, \& Applications: Software for Humanity}, date = {2013-10-31}, series = {{SPLASH SRC}}, pages = {117-118}, doi = {10.1145/2508075.2514878}, address = {Indianapolis, IN}, abstract = {Researchers use shared computing clusters to ask interesting questions and wish to maximize their utilization. Currently, optimizations focus on individual programs. We present task fusion to automatically merge multiple tasks into a single task. An example implementation shows fused tasks take 14-90\% less time than running the tasks individually.}, } @inproceedings{dyer13:declarative-visitors, author = {Dyer, Robert and Rajan, Hridesh and Nguyen, Tien N.}, title = {Declarative Visitors to Ease Fine-grained Source Code Mining with Full History on Billions of {AST} Nodes}, booktitle = {Proceedings of the 12th International Conference on Generative Programming: Concepts \& Experiences}, date = {2013-10-27}, series = {{GPCE}}, doi = {10.1145/2637365.2517226}, pages = {23-32}, address = {Indianapolis, IN}, abstract = {Software repositories contain a vast wealth of information about software development. Mining these repositories has proven useful for detecting patterns in software development, testing hypotheses for new software engineering approaches, etc. Specifically, mining source code has yielded significant insights into software development artifacts and processes. Unfortunately, mining source code at a large-scale remains a difficult task. Previous approaches had to either limit the scope of the projects studied, limit the scope of the mining task to be more coarse-grained, or sacrifice studying the history of the code due to both human and computational scalability issues. In this paper we address the substantial challenges of mining source code: a) at a very large scale; b) at a fine-grained level of detail; and c) with full history information. To address these challenges, we present domain-specific language features for source code mining. Our language features are inspired by object-oriented visitors and provide a default depth-first traversal strategy along with two expressions for defining custom traversals. We provide an implementation of these features in the Boa infrastructure for software repository mining and describe a code generation strategy into Java code. To show the usability of our domain-specific language features, we reproduced over 40 source code mining tasks from two large-scale previous studies in just 2 person-weeks. The resulting code for these tasks show between 2.0x--4.8x reduction in code size. Finally we perform a small controlled experiment to gain insights into how easily mining tasks written using our language features can be understood, with no prior training. We show a substantial number of tasks (77\%) were understood by study participants, in about 3 minutes per task.}, } @inproceedings{dyer12:ao-interfaces, author = {Dyer, Robert and Rajan, Hridesh and Cai, Yuanfang}, title = {An Exploratory Study of the Design Impact of Language Features for Aspect-Oriented Interfaces}, date = {2012-03-30}, isbn = {9781450310925}, publisher = {Association for Computing Machinery}, doi = {10.1145/2162049.2162067}, booktitle = {Proceedings of the 11th Annual International Conference on Aspect-Oriented Software Development}, pages = {143-154}, address = {Potsdam, Germany}, series = {{AOSD}}, abstract = {A variety of language features to modularize crosscutting concerns have recently been discussed, e.g. open modules, annotation-based pointcuts, explicit join points, and quantified-typed events. All of these ideas are essentially a form of aspect-oriented interface between object-oriented and crosscutting modules, but the representation of this interface differs. While previous works have studied maintenance of AO programs versus OO programs, an empirical comparison of different AO interfaces to each other to investigate their benefits has not been performed. The main contribution of this work is a rigorous empirical study that evaluates the effectiveness of these proposals for AO interfaces towards software maintenance by applying them to 35 different releases of a software product line called MobileMedia and 50 different releases of a web application called Health Watcher. Our comparative analysis using quantitative metrics proposed by Chidamber and Kemerer shows the strengths and weaknesses of these AO interface proposals. Our change impact analysis shows the design stability provided by each of these recent proposals for AO interfaces.}, } @inproceedings{dyer08:nu, author = {Dyer, Robert and Rajan, Hridesh}, title = {{Nu}: A Dynamic Aspect-Oriented Intermediate Language Model and Virtual Machine for Flexible Runtime Adaptation}, date = {2008-03-31}, isbn = {9781605580449}, publisher = {Association for Computing Machinery}, doi = {10.1145/1353482.1353505}, booktitle = {Proceedings of the 7th International Conference on Aspect-Oriented Software Development}, pages = {191-202}, address = {Brussels, Belgium}, series = {{AOSD}}, abstract = {A variety of dynamic aspect-oriented language constructs are proposed in recent literature with corresponding, compelling use cases. Such constructs demonstrate the need to dynamically adapt the set of join points intercepted at a fine-grained level. The notion of morphing aspects and continuous weaving is motivated by this need. We propose an intermediate language model called Nu, that extends object-oriented intermediate language models with two fine-grained deployment primitives: bind and remove. These primitives offer a higher level of abstraction as a compilation target for dynamic aspect-oriented language constructs, thereby making it easier to support such constructs. We present the design and implementation of the Nu model in the Sun Hotspot VM, an industrial strength virtual machine, which serves to show the feasibility of the intermediate language design. Our implementation uses dedicated caching mechanisms to significantly reduce the amortized costs of join point dispatch. Our evaluation shows that the cost of supporting a dynamic deployment model can be reduced to as little as \textasciitilde{}1.5\%. We demonstrate the potential utility of the intermediate language design by expressing a variety of aspect-oriented source language constructs of dynamic flavor such as CaeserJ's deploy, history-based pointcuts, and control flow constructs in terms of the Nu model.}, } @inproceedings{moloney26:tacas, author = {Moloney, Charles and Dyer, Robert and Sherman, Elena}, title = {Demonstrating {ARG-V}'s Generation of Realistic {Java} Benchmarks for {SV-COMP}}, date = {2026-04-15}, booktitle = {Proceedings of the International Conference on Tools and Algorithms for the Construction and Analysis of Systems}, pages = {{277-285}}, doi = {10.1007/978-3-032-22749-2}, series = {{TACAS}}, location = {Turin, Italy}, abstract = {The SV-COMP competition provides a state-of-the-art platform for evaluating software verification tools on a standardized set of verification tasks. Consequently, verifier development outcomes are influenced by the composition of program benchmarks included in SV-COMP. When expanding this benchmark corpus, it is crucial to consider whether newly added programs cause verifiers to exhibit behavior distinct from that observed on existing benchmarks. Doing so helps mitigate external threats to the validity of the competition’s results. In this paper, we present the application of the ARG-V tool for automatically generating Java verification benchmarks in the SV-COMP format. We demonstrate that, on a newly generated set of 68 realistic benchmarks, all four leading Java verifiers decrease in accuracy and recall compared to their performance on the existing benchmark suite. These findings highlight the potential of ARG-V to enhance the comprehensiveness and realism of verification tool evaluation, while also providing a roadmap for verifier developers aiming to improve their tools’ applicability to real-world software.}, } @inproceedings{sigurdson24:demo-boidae, author = {Sigurdson, Brian and Flint, Samuel W. and Dyer, Robert}, title = {{Boidae}: Your Personal Mining Platform}, date = {2024-04-17}, booktitle = {Proceedings of the 46th IEEE/ACM International Conference on Software Engineering}, pages = {{40-43}}, doi = {10.1145/3639478.3640026}, series = {{ICSE}}, address = {Lisbon, Portugal}, abstract = {Mining software repositories is a useful technique for researchers and practitioners to see what software developers actually do when developing software. Tools like Boa provide users with the ability to easily mine these open-source software repositories at a very large scale, with datasets containing hundreds of thousands of projects. The trade-off is that users must use the provided infrastructure, query language, runtime, and datasets and this might not fit all analysis needs. In this work, we present Boidae: a family of Boa installations controlled and customized by users. Boidae uses automation tools such as Ansible and Docker to facilitate the deployment of a customized Boa installation. In particular, Boidae allows the creation of custom datasets generated from any set of Git repositories, with helper scripts to aid in finding and cloning repositories from GitHub and SourceForge. In this paper, we briefly describe the architecture of Boidae and how researchers can utilize the infrastructure to generate custom datasets. Boidae's scripts and all infrastructure it builds upon are open-sourced. A video demonstration of Boidae's installation and extension is available at https://go.unl.edu/boidae.}, } @inproceedings{brunner20:demo-paclab, author = {Brunner, Rebecca and Dyer, Robert and Paquin, Maria and Sherman, Elena}, title = {{PAClab}: A Program Analysis Collaboratory}, date = {2020-11-08}, isbn = {9781450370431}, publisher = {Association for Computing Machinery}, doi = {10.1145/3368089.3417936}, booktitle = {Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering}, pages = {1616-1620}, address = {Virtual Event, USA}, series = {{ESEC/FSE}}, abstract = {We present a web-based Program Analysis Collaboratory (PAClab) tool that helps researchers to obtain realistic program benchmarks using user-defined selection criteria. Based on selection criteria, PAClab identifies relevant projects and its programs from open-source repositories, obtains those programs, and if necessary performs sound program transformations to adapt them to the targeted verification tool. PAClab makes the resulting program benchmarks available for download. PAClab is designed as a scalable, modular, and parametrizable tool that takes advantage of a computer cluster to handle multiple user requests.}, } @inproceedings{dyer15:demo-mining-features, author = {Dyer, Robert and Rajan, Hridesh and Nguyen, Tien N. and Nguyen, Hoan Anh}, title = {Demonstrating Programming Language Feature Mining Using {Boa}}, date = {2015-10-30}, isbn = {9781450337229}, publisher = {Association for Computing Machinery}, doi = {10.1145/2814189.2814192}, booktitle = {Companion Proceedings of the 2015 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity}, pages = {13-14}, address = {Pittsburgh, PA, USA}, series = {{SPLASH}}, abstract = {Programming language researchers often study real-world projects to see how language features have been adopted and are being used. Typically researchers choose a small number of projects to study, due to the immense challenges associated with finding, downloading, storing, processing, and querying large amounts of data. The Boa programming language and infrastructure was designed to solve these challenges and allow researchers to focus on simply asking the right questions. Boa provides a domain-specific language to abstract details of how to mine hundreds of thousands of projects and also abstracts how to efficiently query that data. We have previously used this platform to perform a large study of the adoption of Java's language features over time. In this demonstration, we will show you how we used Boa to quickly analyze billions of AST nodes and study the adoption of Java's language features.}, } @inproceedings{nguyen15:demo-consensus-mining, author = {Nguyen, Hoan Anh and Dyer, Robert and Nguyen, Tien N. and Rajan, Hridesh}, title = {Consensus-Based Mining of {API} Preconditions in Big Code}, date = {2015-10-30}, isbn = {9781450337229}, publisher = {Association for Computing Machinery}, doi = {10.1145/2814189.2816271}, booktitle = {Companion Proceedings of the 2015 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity}, pages = {5-6}, address = {Pittsburgh, PA, USA}, series = {{SPLASH}}, abstract = {Formal specifications for APIs help developers correctly use them and enable checker tools automatically verify their uses. However, formal specifications are not always available with released APIs. In this work, we demonstrate an approach for mining API preconditions from a large-scale corpus of open-source software. It considers conditions guarding API calls in client code as potential preconditions of the corresponding APIs. Then it uses consensus among a large number of API usages to keep the ones appearing in the majority. Finally, the mined preconditions are ranked based on their frequencies and reported to users.}, } @inproceedings{dyer13:demo-boa, author = {Dyer, Robert and Nguyen, Hoan Anh and Rajan, Hridesh and Nguyen, Tien N.}, title = {Mining Source Code Repositories with {Boa}}, date = {2013-10-31}, isbn = {9781450319959}, publisher = {Association for Computing Machinery}, doi = {10.1145/2508075.2514570}, booktitle = {Proceedings of the 2013 Companion Publication for Conference on Systems, Programming, \& Applications: Software for Humanity}, pages = {13-14}, address = {Indianapolis, IN, USA}, series = {{SPLASH}}, abstract = {Mining source code has become a common task for researchers and yielded significant benefits for the software engineering community. Mining source code however is a very difficult and time consuming task. The Boa language and infrastructure was designed to ease mining of project and revision metadata. Recently Boa was extended to support mining source code and currently contains source code for over 23k Java projects, including full revision histories. In this demonstration we pose source code mining tasks and give solutions using Boa. We then execute these programs via our web-based infrastructure and show how to easily make the results available for future researchers.}, } @inproceedings{dyer12:demo-boa, author = {Dyer, Robert and Nguyen, Hoan Anh and Rajan, Hridesh and Nguyen, Tien N.}, title = {Analyzing Ultra-Large-Scale Code Corpus with {Boa}}, date = {2012-10-22}, isbn = {9781450315630}, publisher = {Association for Computing Machinery}, doi = {10.1145/2384716.2384729}, booktitle = {Proceedings of the 3rd Annual Conference on Systems, Programming, and Applications: Software for Humanity}, pages = {25-26}, address = {Tucson, AZ, USA}, series = {{SPLASH}}, abstract = {Analyzing the wealth of information contained in software repositories requires significant expertise in mining techniques as well as a large infrastructure. In order to make this information more reachable for non-experts, we present the Boa language and infrastructure. Using Boa, these mining tasks are much simpler to write as the details are abstracted away. Boa programs also run on a distributed cluster to automatically provide massive parallelization to users and return results in minutes instead of potentially days.}, } @inproceedings{rajan11b:demo-ptolemy, author = {Rajan, Hridesh and Mooney, Sean and Leavens, Gary T. and Dyer, Robert and Fernando, Rex D. and Darab, Mohammad Ali Darvish and Welter, Bryan}, title = {Modularizing Crosscutting Concerns with {Ptolemy}}, date = {2011-10-26}, isbn = {9781450309424}, publisher = {Association for Computing Machinery}, doi = {10.1145/2048147.2048163}, booktitle = {Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion}, pages = {31-32}, address = {Portland, OR, USA}, series = {{OOPSLA}}, abstract = {In this demonstration we show our language Ptolemy, which allows for separation of crosscutting concerns while maintaining modular reasoning. We demonstrate the benefits of Ptolemy over existing aspect-oriented languages and implicit invocation designs. Ptolemy's quantified, typed events provide a flexible quantification mechanism that acts as a declarative interface between object-oriented code and crosscutting code. Events are announced explicitly and declaratively. Event types allow for compile-time errors and avoid the fragile pointcut problem of aspect-oriented languages. The interface provided by event types also allows for modular reasoning, without considering all aspects in the system. The declarative event announcement allows avoiding writing tedious and error-prone boiler-plate code that implicit invocation designs require. We demonstrate several realistic examples that showcase the features of the Ptolemy language and show use of Ptolemy's compiler. The demonstrated compiler is built on top of the OpenJDK Java compiler (javac), providing full backwards compatibility with existing Java sources as well as ease of integration into the existing tool chains. We show how to integrate the compiler into both existing Ant and Eclipse builds.}, } @inproceedings{rajan11:demo-ptolemy, author = {Rajan, Hridesh and Mooney, Sean and Leavens, Gary T. and Dyer, Robert and Fernando, Rex D. and Darab, Mohammad Ali Darvish and Welter, Bryan}, title = {Modularizing Crosscutting Concerns with {Ptolemy}}, date = {2011-07-27}, booktitle = {Proceedings of the 25th European Conference on Object-Oriented Programming}, address = {Lancaster, United Kingdom}, series = {{ECOOP}}, } @article{batole26:neuralstate, author = {Batole, Fraol and Manke, Ruchira and Dyer, Robert and Nguyen, Tien N. and Rajan, Hridesh}, title = {Typestate-based Fault Localization of {API} Usage Violations in a Deep Learning Program}, date = {2026-01-21}, pages = {{1000-1014}}, volume = {52}, number = {3}, publisher = {{IEEE}}, address = {NJ, USA}, journal = {{IEEE} Transactions on Software Engineering}, series = {{TSE}}, abstract = {Deep Learning (DL) applications have become essential in numerous domains, yet they remain plagued by subtle bugs that cause 66\% of crashes in production systems. These failures primarily stem from API usage violations in complex frameworks like TensorFlow, Keras, and PyTorch, where APIs lack formal specifications and interdependencies between operations remain undocumented. Traditional static analysis tools fail to address DL-specific constraints, such as data dependency between layers. To bridge this critical gap, we propose NeuralState, an approach to detect performance and program crash bugs in a DL program. NeuralState follows a four-step process: (i) gather specifications for Deep Learning operations from different sources; (ii) introduce abstract states to represent these Deep Learning operations; (iii) design formal rules for transitioning between states based on the specifications; (iv) utilize a combination of standard analysis techniques (i.e., typestate and value propagation) to identify bugs in a DL program. Our evaluation on real-world benchmarks demonstrates NeuralState's effectiveness, achieving a 25\% improvement in precision and 63\% improvement in recall compared to state-of-the-art tools. Most importantly, NEURALSTATE successfully detects 18 subtle bugs in 45 real-world programs that existing techniques miss entirely.}, doi = {10.1109/TSE.2026.3656464}, } @article{flint25:python-tracking, author = {Flint, Samuel W. and Chauhan, Jigyasa and Mansoor, Niloofar and Dyer, Robert and Sharif, Bonita}, title = {An Exploratory Eye Tracking Study on How Developers Classify and Debug {Python} Code in Different Paradigms}, date = {2026-04-30}, publisher = {Kluwer Academic Publishers}, address = {USA}, journal = {Empirical Software Engineering}, series = {{EMSE}}, issue_date = {Apr 2026}, numpages = {39}, volume = {31}, number = {129}, issn = {1382-3256}, doi = {10.1007/s10664-025-10774-3}, abstract = {Modern programming languages, such as Python, support language features from several paradigms, such as object-oriented, procedural, and functional. Research has shown that code written in some paradigms can be harder to comprehend, but to date, no research has looked at which paradigm-specific language features impact comprehension. To this end, this study seeks to uncover which paradigm-specific features impactcomprehension and debugging of code or how multi-paradigm code might affect a developer's ability to do so. We present an exploratory empirical eye-tracking study to investigate 1) how developers classify the predominant paradigm in Python code and 2) how the paradigm affects their ability to debug Python code. The goal is to uncover if specific language features are looked at more often while classifying and debugging code with a predominant paradigm. Twenty-nine developers (primarily students) were recruited for the study and were each given four classification and four debugging tasks in Python. Eye movements were recorded during all the tasks. The results indicate confusion in labeling Functional and Procedural paradigms, but not Object-Oriented. The code with predominantly functional paradigms also took the longest to complete. Changing the predominant paradigm did not affect the ability to debug the code, though developers did rate themselves with lower confidence for Functional code. We report significant differences in reading patterns during debugging, especially in the Functional code. During classification, results show that developers do not necessarily read paradigm-relevant token types.}, } @article{perezrosero25:wiaszz, author = {Perez-Rosero, Salom/'{e} and Dyer, Robert and Flint, Samuel W. and McIntosh, Shane and Srisa-An, Witawas}, title = {{WIASZZ}: Work Item Aware {SZZ}}, date = {2025-03-01}, publisher = {Kluwer Academic Publishers}, address = {USA}, journal = {Empirical Software Engineering}, series = {{EMSE}}, issue_date = {Mar 2025}, numpages = {28}, volume = {30}, number = {75}, issn = {1382-3256}, doi = {10.1007/s10664-025-10616-2}, abstract = {Many software engineering maintenance tasks require linking a commit that induced a bug with the commit that later fixed that bug. Several existing SZZ algorithms provide a way to identify the potential commit that induced a bug when given a fixing commit as input. Prior work introduced the notion of a "work item", a logical grouping of commits that could be a single unit of work. Our key insight in this work is to recognize that a bug-inducing commit and the fix(es) for that bug together represent a "work item." It is not currently understood how these work items, which are logical groups of revisions addressing a single issue or feature, could impact the performance of algorithms such as SZZ. In this paper, we propose a heuristic that, given an input commit, uses information about changed methods to identify related commits that form a work item with the input commit. We hypothesize that given such a work item identifying heuristic, we can identify bug-inducing commits more accurately than existing SZZ approaches. We then build a new variant of SZZ that we call Work Item Aware SZZ (WIA-SZZ), that leverages our work item detecting heuristic to first suggest bug-inducing commits. If our heuristic fails to find any candidates, we then fall back to baseline variants of SZZ. We conduct a manual evaluation to assess the accuracy of our heuristic to identify work items. Our evaluation reveals the heuristic is 64\% accurate in finding work items, but most importantly it is able to find many bug-inducing commits. We then evaluate our approach on 818 repositories that have been previously used to study the performance of SZZ, comparing our work against six SZZ variants. That evaluation shows an improvement in F1 scores ranging from 2\% to 9\% overall. When considering only the subset of cases where work items were identified, the improvement increases from 3\% to 14\%.}, } @article{flint24:typeinfer, author = {Flint, Samuel W. and Keshk, Ali M. and Dyer, Robert and Bagheri, Hamid}, title = {How Do Developers Use Type Inference: An Exploratory Study in {Kotlin}}, date = {2025-01-16}, issue_date = {Jan 2025}, publisher = {Kluwer Academic Publishers}, address = {USA}, volume = {30}, number = {55}, issn = {1382-3256}, doi = {10.1007/s10664-024-10585-y}, journal = {Empirical Software Engineering}, series = {{EMSE}}, numpages = {29}, abstract = {Statically typed languages offer numerous benefits to developers, such as improved code quality and reduced runtime errors, but they also require the overhead of manual type annotations. To mitigate this burden, language designers have started incorporating support for type inference, where the compiler infers the type of a variable based on its declaration/usage context. As a result, type annotations are optional in certain contexts, and developers are empowered to use type inference in these situations. However, the usage patterns of type annotations in languages that support type inference are unclear. These patterns can help provide evidence for further research in program comprehension, in language design, and for education. We conduct a large-scale empirical study using Boa, a tool for mining software repositories, to investigate when and where developers use type inference in 498,963 Kotlin projects. We choose Kotlin because it is the default language for Android development, one of the largest software marketplaces. Additionally, Kotlin has supported declaration-site optional type annotations from its initial release. Our findings reveal that type inference is frequently employed for local variables and variables initialized with method calls declared outside the file are more likely to use type inference. These results have significant implications for language designers, providing valuable insight into where to allow type inference and how to optimize type inference algorithms for maximum efficiency, ultimately improving the development experience for developers.}, } @article{flint22:pitfalls, author = {Flint, Samuel W. and Chauhan, Jigyasa and Dyer, Robert}, title = {Pitfalls and Guidelines for Using Time-Based {Git} Data}, date = {2022-10-06}, issue_date = {Dec 2022}, publisher = {Kluwer Academic Publishers}, address = {USA}, volume = {27}, number = {7}, issn = {1382-3256}, doi = {10.1007/s10664-022-10200-y}, journal = {Empirical Software Engineering}, series = {{EMSE}}, numpages = {55}, abstract = {Many software engineering research papers rely on time-based data (e.g., commit timestamps, issue report creation/update/close dates, release dates). Like most real-world data however, time-based data is often dirty. To date, there are no studies that quantify how frequently such data is used by the software engineering research community, or investigate sources of and quantify how often such data is dirty. Depending on the research task and method used, including such dirty data could affect the research results. This paper presents the first survey of papers that utilize time-based data, published in the Mining Software Repositories (MSR) conference series. Out of the 690 technical track and data papers published in MSR 2004--2020, we saw at least 35\% of papers utilized time-based data. We then used the Boa and Software Heritage infrastructures to help identify and quantify several sources of dirty commit timestamp data. Finally we provide guidelines/best practices for researchers utilizing time-based data from Git repositories.}, } @article{bagherzadeh16:modular-reasoning, title = {Modular reasoning in the presence of event subtyping}, author = {Bagherzadeh, Mehdi and Dyer, Robert and Fernando, Rex D. and S{\'a}nchez, Jos{\'e} and Rajan, Hridesh}, journal = {Transactions on Modularity and Composition I}, volume = {1}, number = {1}, series = {{TOMC}}, pages = {167-223}, date = {2016-09}, isbn = {978-3-319-46969-0}, doi = {10.1007/978-3-319-46969-0\_5}, publisher = {Springer}, abstract = {Separating crosscutting concerns while preserving modular reasoning is challenging. Type-based interfaces (event types) separate modularized crosscutting concerns (observers) and traditional object-oriented concerns (subjects). Event types paired with event specifications were shown to be effective in enabling modular reasoning about subjects and observers. Similar to class subtyping, organizing event types into subtyping hierarchies is beneficial. However, unrelated behaviors of observers and their arbitrary execution orders could cause unique, somewhat counterintuitive, reasoning challenges in the presence of event subtyping. These challenges threaten both tractability of reasoning and reuse of event types. This work makes three contributions. First, we pose and explain these challenges. Second, we propose an event-based calculus to show how these challenges can be overcome. Finally, we present modular reasoning rules of our technique and show its applicability to other event-based techniques.}, } @article{dyer15:boa-journal, author = {Dyer, Robert and Nguyen, Hoan Anh and Rajan, Hridesh and Nguyen, Tien N.}, title = {{Boa}: Ultra-Large-Scale Software Repository and Source-Code Mining}, journal = {ACM Transactions on Software Engineering and Methodology}, series = {{TOSEM}}, issue_date = {December 2015}, volume = {25}, number = {1}, date = {2015-12}, pages = {7:1-7:34}, articleno = {7}, doi = {10.1145/2803171}, abstract = {In today's software-centric world, ultra-large-scale software repositories, such as SourceForge, GitHub, and Google Code, are the new library of Alexandria. They contain an enormous corpus of software and related information. Scientists and engineers alike are interested in analyzing this wealth of information. However, systematic extraction and analysis of relevant data from these repositories for testing hypotheses is hard, and best left for mining software repository (MSR) experts! Specifically, mining source code yields significant insights into software development artifacts and processes. Unfortunately, mining source code at a large scale remains a difficult task. Previous approaches had to either limit the scope of the projects studied, limit the scope of the mining task to be more coarse grained, or sacrifice studying the history of the code. In this article we address mining source code: (a) at a very large scale; (b) at a fine-grained level of detail; and (c) with full history information. To address these challenges, we present domain-specific language features for source-code mining in our language and infrastructure called Boa. The goal of Boa is to ease testing MSR-related hypotheses. Our evaluation demonstrates that Boa substantially reduces programming efforts, thus lowering the barrier to entry. We also show drastic improvements in scalability.}, } @article{dyer13:ao-interfaces, author = {Dyer, Robert and Rajan, Hridesh and Cai, Yuanfang}, title = {Language Features for Software Evolution and Aspect-Oriented Interfaces: An Exploratory Study}, date = {2013-04}, isbn = {978-3-642-36963-6}, volume = {1}, number = {1}, publisher = {Springer-Verlag}, address = {Berlin, Heidelberg}, journal = {Transactions on Aspect-Oriented Software Development X}, series = {{TAOSD}}, doi = {10.1007/978-3-642-36964-3\_5}, pages = {148-183}, abstract = {A variety of language features to modularize cross-cutting concerns have recently been discussed, e.g., open modules, annotation-based pointcuts, explicit join points, and quantified-typed events. All of these ideas are essentially a form of aspect-oriented interface between object-oriented and cross-cutting modules, but the representation of this interface differs. Previous works have studied maintenance benefits of AO programs compared to OO programs, by usually looking at a single AO interface. Other works have looked at several AO interfaces, but only on relatively small systems or systems with only one type of aspectual behavior. Thus, there is a need for a study that examines large, realistic systems for several AO interfaces to determine what problems arise and in which interface(s). The main contribution of this work is a rigorous empirical study that evaluates the effectiveness of these proposals for 4 different AO interfaces by applying them to 35 different releases of a software product line called MobileMedia and 50 different releases of a Web application called Health Watcher. In total, over 400k lines of code were studied across all releases. Our comparative analysis using quantitative metrics proposed by Chidamber and Kemerer shows the strengths and weaknesses of these AO interface proposals. Our change impact analysis shows the design stability provided by each of these recent proposals for AO interfaces.}, } @article{dyer10:dynamic-ao, author = {Dyer, Robert and Rajan, Hridesh}, title = {Supporting Dynamic Aspect-Oriented Features}, date = {2010-08}, issue_date = {August 2010}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, volume = {20}, number = {2}, issn = {1049-331X}, doi = {10.1145/1824760.1824764}, journal = {ACM Transactions on Software Engineering and Methodology}, series = {{TOSEM}}, articleno = {7}, numpages = {34}, abstract = {Dynamic aspect-oriented (AO) features have important software engineering benefits such as allowing unanticipated software evolution and maintenance. It is thus important to efficiently support these features in language implementations. Current implementations incur unnecessary design-time and runtime overhead due to the lack of support in underlying intermediate language (IL) models. To address this problem, we present a flexible and dynamic IL model that we call Nu. The Nu model provides a higher level of abstraction compared to traditional object-oriented ILs, making it easier to efficiently support dynamic AO features. We demonstrate these benefits by providing an industrial-strength VM implementation for Nu, by showing translation strategies from dynamic source-level constructs to Nu and by analyzing the performance of the resulting IL code. Nu's VM extends the Sun Hotspot VM interpreter and uses a novel caching mechanism to significantly reduce the amortized costs of join point dispatch. Our evaluation using standard benchmarks shows that the overhead of supporting a dynamic deployment model can be reduced to as little as \textasciitilde{}1.5\%. Nu provides an improved compilation target for dynamic deployment features, which makes it easier to support such features with corresponding software engineering benefits in software evolution and maintenance and in runtime verification.}, } @inproceedings{su18:poster-consensus, author = {Su, Jingyi and Arafat, Mohd and Dyer, Robert}, title = {Using Consensus to Automatically Infer Post-Conditions}, date = {2018-05-30}, isbn = {9781450356633}, publisher = {Association for Computing Machinery}, doi = {10.1145/3183440.3195096}, booktitle = {Proceedings of the 40th International Conference on Software Engineering: Companion Proceeedings}, pages = {202-203}, address = {Gothenburg, Sweden}, series = {{ICSE}}, abstract = {Formal behavioral specifications help ensure the correctness of programs. Writing such specifications by hand however is time-consuming and requires substantial expertise. Previous studies have shown how to use a notion of consensus to automatically infer pre-conditions for APIs by using a large set of projects. In this work, we propose a similar idea of consensus to automatically infer post-conditions for popular APIs. We propose two new algorithms for mining potential post-conditions from API client code. The first algorithm looks for guarded post-conditions that test the value returned from the API and throws an exception. The second algorithm looks for values flowing from the API to another API with already known preconditions, which recommends them as post-conditions of the first API.}, } @inproceedings{dyer13:task-fusion-poster, author = {Dyer, Robert}, title = {Task Fusion: Improving Utilization of Multi-user Clusters}, booktitle = {Proceedings of the companion publication for conference on Systems, Programming, Languages, \& Applications: Software for Humanity}, date = {2013-10-31}, series = {{SPLASH SRC}}, pages = {117-118}, doi = {10.1145/2508075.2514878}, address = {Indianapolis, IN}, abstract = {Researchers use shared computing clusters to ask interesting questions and wish to maximize their utilization. Currently, optimizations focus on individual programs. We present task fusion to automatically merge multiple tasks into a single task. An example implementation shows fused tasks take 14-90\% less time than running the tasks individually.}, } @inproceedings{dyer12:poster-boa, author = {Dyer, Robert and Nguyen, Hoan Anh and Rajan, Hridesh and Nguyen, Tien N.}, title = {{Boa}: Analyzing Ultra-Large-Scale Code Corpus}, date = {2012-10-22}, isbn = {9781450315630}, publisher = {Association for Computing Machinery}, doi = {10.1145/2384716.2384752}, booktitle = {Proceedings of the 3rd Annual Conference on Systems, Programming, and Applications: Software for Humanity}, pages = {87-88}, address = {Tucson, AZ, USA}, series = {{SPLASH}}, abstract = {Software repositories contain an enormous amount of information such as revisions and bugs. Analyzing this data requires knowledge in mining software repositories and a large amount of infrastructure. We present our infrastructure Boa to ease such analyses. Our results show writing analyses with our framework is simpler and executes faster.}, } @inproceedings{dyer06:poster-nu, author = {Dyer, Robert and Narayanappa, Harish and Rajan, Hridesh}, title = {{Nu}: Preserving Design Modularity in Object Code}, date = {2006-11-07}, publisher = {Association for Computing Machinery}, doi = {10.1145/1218776.1218802}, booktitle = {Proceedings of {ACM} {SIGSOFT} International Symposium on Foundations of Software Engineering}, series = {{FSE}}, address = {Portland, OR, USA}, pages = {1-2}, abstract = {For a number of reasons, such as to generate object code that is compliant with the existing virtual machines (VM), current compilers for aspect-oriented languages sacrifice design modularity when transforming source to object code by losing textual locality and intermingling concerns in the object code. Sacrificing design modularity has significant costs, especially in terms of the speed of incremental compilation. We present an intermediate language design that preserves aspect-oriented design modularity in Java byte code. We briefly describe our extensions to the Sun Hotspot VM to support the new intermediate language design.}, } @inproceedings{shekarforoush17:poster-classifying-commits, author = {Shekarforoush, SeyedHamid and Green, Robert and Dyer, Robert}, title = {Classifying Commit Messages: A Case Study in Resampling Techniques}, date = {2017-05-18}, booktitle = {Proceedings of the 30th International Joint Conference on Neural Networks}, series = {{IJCNN}}, address = {Anchorage, AK, USA}, } @inproceedings{dyer15:poster-boa, author = {Dyer, Robert and Rajan, Hridesh and Nguyen, Hoan Anh and Nguyen, Tien N.}, title = {Mining Billions of {AST} Nodes to Study Actual and Potential Usage of {Java} Language Features}, date = {2015-10-28}, booktitle = {Proceedings of the 6th International Conference on Systems, Programming, Languages, and Applications: Software for Humanity}, series = {{SPLASH}}, address = {Pittsburgh, PA, USA}, } @inproceedings{rajan15:poster-inferring-specs, author = {Rajan, Hridesh and Nguyen, Tien N. and Leavens, Gary T. and Dyer, Robert}, title = {Inferring Behavioral Specifications from Large-scale Repositories by Leveraging Collective Intelligence}, date = {2015-05-21}, booktitle = {Proceedings of the 37th International Conference on Software Engineering New Ideas and Emerging Results}, series = {{ICSE NIER}}, address = {Firenze, Italy}, } @inproceedings{dyer08:poster-weave-now, author = {Dyer, Robert and Setty, Rakesh and Rajan, Hridesh}, title = {Weave Now or Weave Later: A Test Driven Development Perspective on Aspect-oriented Deployment Models}, date = {2008-04-01}, booktitle = {Proceedings of the 7th International Conference on Aspect-Oriented Software Development}, series = {{AOSD}}, address = {Brussels, Belgium}, } @inproceedings{dyer07:poster-nu, author = {Dyer, Robert and Rajan, Hridesh}, title = {Enhanced Intermediate Language Design to Preserve {AO} Modularity in Object Code}, date = {2007-03-15}, booktitle = {Proceedings of the 6th International Conference on Aspect-Oriented Software Development}, series = {{AOSD}}, address = {Vancouver, Canada}, } @inproceedings{setty07:poster-nu, author = {Setty, Rakesh and Dyer, Robert and Rajan, Hridesh}, title = {Modular Compilation Strategies for {AspectJ} Constructs to {Nu} Intermediate Language}, date = {2007-03-15}, booktitle = {Proceedings of the 6th International Conference on Aspect-Oriented Software Development}, series = {{AOSD}}, address = {Vancouver, Canada}, } @techreport{setty08:weave-now-later, author = {Setty, Rakesh and Dyer, Robert and Rajan, Hridesh}, title = {Weave Now or Weave Later: A Test Driven Development Perspective on Aspect-oriented Deployment Models}, booktitle = {Technical Report #08-02, Department of Computer Science}, institution = {Iowa State University}, number = {08-02}, date = {2008-02-26}, abstract = {The choice to use static or load-time weaving techniques in the development cycle of large AspectJ programs is not clear. It is a common practice to iteratively remove errors from programs by making small changes, recompiling, and testing the change. Previous research has shown that incremental compilation of aspect-oriented programs using static weavers can take longer compared to object-oriented programs, which in turn increases the time spent in each iteration. It has been suggested that utilizing load-time weavers can potentially alleviate the problem. However, there is a trade-off involved which is the increased execution time due to the overhead involved in weaving while loading classes. In this paper, we report on a case study in which we examine the parameters that differentiate the two techniques during the edit-compile-test cycle and determine which technique is more favorable as these parameters vary. Our results show that the parameters that differentiate the techniques are the number of classes loaded, the size of the project and the number of join points executed including repetitions. We also find that load-time weaving does solve the problem of incremental compilation in aspect-oriented programming to some extent under some favorable values of the parameters mentioned. We find that the performance of static weaving with respect to load-time weaving is directly proportional to the number of classes loaded during test, and the performance of load-time weaving with respect to static weaving is directly proportional to the size of the project and the number of join points executed. Our results also show that the percentage of join points affected by aspects do not differentiate between the two techniques.}, } @techreport{bagherzadeh08:instance-events, author = {Bagherzadeh, Mehdi and Dyer, Robert and Long, Yuheng and Rajan, Hridesh}, title = {Instance-level Quantified, Typed Events for Improved Separation of Integration Concerns}, booktitle = {Technical Report #08-15, Department of Computer Science}, institution = {Iowa State University}, number = {08-15}, date = {2008-12-23}, abstract = {Integrated systems are those where components must behave together in order to fulfill overall requirements. In such systems, modularization of integration relationships is important for enabling separate component compilation, testing, and debugging, and for enhanced reuse. Existing languages and approaches for modularizing integration relationships work, but do not solve all problems. In particular, they either do not completely decouple components or require workarounds, which at a minimum incurs design and performance overheads. In this work, we discuss instance-level quantified, typed events, which solve all of these problems. The technical contributions include: the design, semantics, and type system of instance-level quantified, typed events and a proof of its soundness. A formalized semantics is new to this paper, as there have been no previous formalizations of language features that aim to modularize separation of integration relationships. To demonstrate the feasibility of our language design, we have implemented this design in an interpreter. To provide an initial assessment of the language's benefits, we have implemented canonical examples in the literature. Our initial assessments show that instance-level quantified, typed events improve the separation of integration concerns over previous language design proposals.}, } @techreport{dyer06:modular-compilation, author = {Dyer, Robert and Rajan, Hridesh}, title = {Modular Compilation Strategies for Aspect-Oriented Constructs}, booktitle = {Technical Report #06-30, Department of Computer Science}, institution = {Iowa State University}, number = {06-30}, date = {2006-09-22}, abstract = {In our previous work, we presented an aspect-oriented intermediate language, named Nu, to preserve design modularity in object code. Nu is based on two primitives: bind and remove. We showed that maintaining modularity in object code significantly improved the incremental compilation time of aspect-oriented programs. The key contribution of this work is a set of compilation strategies to Nu for a number of AspectJ constructs such as control flow (cflow and cflowbelow), instantiation (perthis, pertarget, percflow, percflowbelow) and dynamic checks (if, this, target, args), as well as composition operators (\&\& and ||). The motivation was to determine if these high-level language constructs need to be supported in the intermediate language. Our compilation strategies are modular and textually local. To compile a construct in a module, only the information about that module's implementation and the specification of other modules referenced in that module are needed. The generated intermediate code for a construct in a source module is confined to a single module in the object code. We show that our compilation strategies improve incremental compilation time of aspect-oriented programs. We also analyze our intermediate language with respect to constructs that are not directly supported.}, } @phdthesis{dyer13:dissertation, author = {Dyer, Robert}, title = {Bringing Ultra-Large-Scale Software Repository Mining to the Masses With {Boa}}, school = {Iowa State University}, date = {2013-12-21}, abstract = {Mining software repositories provides developers and researchers a chance to learn from previous development activities and apply that knowledge to the future. Ultra-large-scale open source repositories (e.g., SourceForge with 350,000+ projects, GitHub with 250,000+ projects, and Google Code with 250,000+ projects) provide an extremely large corpus to perform such mining tasks on. This large corpus allows researchers the opportunity to test new mining techniques and empirically validate new approaches on real-world data. However, the barrier to entry is often extremely high. Researchers interested in mining must know a large number of techniques, languages, tools, etc, each of which is often complex. Additionally, performing mining at the scale proposed above adds additional complexity and often is difficult to achieve. The Boa language and infrastructure was developed to solve these problems. We provide users a domain-specific language tailored for software repository mining and allow them to submit queries via our web-based interface. These queries are then automatically parallelized and executed on a cluster, analyzing a dataset containing almost 700,000 projects, history information from millions of revisions, millions of Java source files, and billions of AST nodes. The language also provides an easy to comprehend visitor syntax to ease writing source code mining queries. The underlying infrastructure contains several optimizations, including query optimizations to make single queries faster as well as a fusion optimization to group queries from multiple users into a single query. The latter optimization is important as Boa is intended to be a shared, community resource. Finally, we show the potential benefit of Boa to the community by reproducing a previously published case study and performing a new case study on the adoption of Java language features.}, } @mastersthesis{dyer08:thesis, author = {Dyer, Robert}, title = {Supporting Dynamic Aspect-Oriented Features}, school = {Iowa State University}, date = {2008-12-20}, abstract = {Aspect-oriented programming techniques extend object-oriented programming with new methods to modularize concerns that otherwise would be non-modular. For example, logging concerns are typically scattered across a system but using aspect-oriented techniques they can be localized into a single high-level module. These techniques typically take modular high-level code and statically transform it into non-modular intermediate code. The contribution of this work is the design and implementation of a flexible and dynamic intermediate-language (IL) model. The main motivation for the design of this IL model is to support a variety of dynamic aspect-oriented language constructs that are proposed in recent literature such as CaeserJ's deploy, history-based pointcuts, and control flow constructs. Our IL model provides a higher level of abstraction compared to traditional object-oriented ILs as a compilation target for such constructs, which makes it easier to provide efficient implementations of these constructs. We demonstrate these benefits by providing an industrial strength implementation for our IL model, by showing translation strategies from dynamic source-level constructs to our improved IL, and by analyzing the performance of the resulting IL code. Our evaluation using the SPEC JVM98 and Java Grande benchmarks shows that the overhead of supporting a dynamic deployment model can be reduced to as little as \textasciitilde{}1.5\%, when compared to the unmodified VM}, } @mastersthesis{moloney26:thesis, author = {Moloney, Charles}, title = {Leveraging Code Embeddings to Identify and Address Blind Spots in Benchmark Creation}, school = {University of Nebraska-Lincoln}, date = {2026-04-08}, abstract = {Formal software verification remains critical for early vulnerability detection, yet benchmarking these tools is costly and often reliant on centralized datasets such as SV-COMP. While such repositories enable standardized evaluation, they introduce risks of overfitting and bias, particularly due to first-party benchmark contributions. To address these limitations, we extend ARG-V, our tool for generating SV-COMP-compatible benchmarks from real-world Java code, with a novel approach of using code embedding techniques to selectively sample from mined code. By leveraging Nomic Embed Code and a cosine-based Minimum Hyperspherical Energy (MHE) objective, we systematically select and transform benchmarks from scraped GitHub code that maximize embedding diversity and minimize redundancy with existing corpora. From 5,100 candidate files, we identify 86 new benchmarks and evaluate them against the state-of-the-art in Java verification. We demonstrate that the proposed benchmarks significantly increase verification difficulty for all four leading Java verifiers at SV-COMP 2026, observing a notable decline in verifier accuracy for all verifiers across assertion safety and exception detection tasks. Qualitative analysis further demonstrates that the benchmarks selected with MHE address numerous "blind spots" for Java features in the SV-COMP corpus, including lambdas, streams, and GUI libraries. These findings highlight the potential of embedding-driven benchmark selection to improve the diversity, realism, and evaluation rigor within software verification.}, } @phdthesis{flint25:thesis, author = {Flint, Samuel W.}, title = {How Developers Use Type-System Related Programming Language Features}, school = {University of Nebraska-Lincoln}, date = {2025-08-01}, abstract = {Background: Statically-annotated types have been shown to aid developers in a number of programming tasks, and this benefit holds true even when static type checking is not used. It is hypothesized that this is because developers use type annotations as in-code documentation. Objective: In this study, we aim to provide evidence that developers use type annotations as in-code documentation. Understanding this hypothesized use will help to understand how, and in what contexts, developers use type information; additionally, it may help to design better development tools and inform educational decisions. Methods: To provide this evidence, we use eye-tracking to determine if developers read type annotations during code comprehension and bug localization in the TypeScript language. Results: We found that developers do not appear to refer to lines containing type annotations or declarations more or less often when they are present, in either code summarization or bug localization tasks. Implications: Finally, we note implications for tool builders (improving availability of type information is important), the development community (building good standards for use of type annotations), and education (deliberate teaching of reading patterns may be wise).}, } @phdthesis{perezrosero24:thesis, author = {Perez-Rosero, Salom/'{e}}, title = {Mining Work Items to Streamline Software Maintenance Tasks}, school = {University of Nebraska-Lincoln}, date = {2024-12-01}, abstract = {Software engineering maintenance tasks often require associating code changes into groupings of related units of work to have as much information as possible about the developments toward addressing a specific code task. A comprehensive understanding of how a code task has evolved helps developers make better decisions about changes in the overall codebase, where a commit represents the set of code changes made to the codebase at a specific time. While the concept of work items as logically related code changes has been primarily theoretical, its impact on software maintenance tasks, such as tracing the origins of bugs or fixes spanning multiple commits while scanning through real-world software repositories' commit histories, remains unexplored. This thesis introduces heuristic-based algorithms to mine work items from commit histories in open-source repositories across different scenarios. First, when issue tags are available throughout the commit history, we developed our first heuristic that mines associations out of validated issue tags from issue tracker systems such as Jira and GitHub. We generated a dataset of approximately 130,000 work items across repositories written in Java, Kotlin, and Python, with each work item group having a numerical confidence score for relatedness. Second, in scenarios where a reference commit is known and the goal is to generate work items associated with it, we developed our second heuristic that implements a method-level tracking mechanism. This approach scans the repository’s commit history backward, identifying overlapping code modifications linked to the reference commit to generate related work items. Third, when an automated and fast way for identifying work items is needed, we explore using pre-trained LLMs with prompts containing different levels of detail from commit diffs and logs to classify commit pairs as related or unrelated work items. Alongside this, we generate two work item datasets with labeled ground truth for fine-tuning purposes. Finally, we apply our top-performing work item heuristic to a software maintenance task in the context of the SZZ algorithms, which aim to track a bug's introducing commit for a given fix commit. Specifically, we built a new SZZ variant that integrates work item awareness, which generated the first empirical evidence that bugs and fixes constitute work items; and reported a 2-9\% F1 score improvement in bug-introducing commit identification over traditional SZZ algorithms, that increases from 3\% to 14\% when considering only the subset of cases where work items were identified.}, } @mastersthesis{chauhan22:thesis, author = {Chauhan, Jigyasa}, title = {An Empirical Study on the Classification of {Python} Language Features Using Eye-Tracking}, school = {University of Nebraska-Lincoln}, date = {2022-12-01}, abstract = {Python, currently one of the most popular programming languages, is an object- oriented language that also provides language feature support for other programming paradigms, such as functional and procedural. It is not currently understood how support for multiple paradigms affects the ability of developers to comprehend that code. Understanding the predominant paradigm in code, and how developers classify the predominant paradigm, can benefit future research in program comprehension as the paradigm may factor into how people comprehend that code. Other researchers may want to look at how the paradigms in the code interact with various code smells. To investigate how developers classify the predominant paradigm in Python code, we performed an empirical study while utilizing an eye-tracker. The goal was to see if developers gaze at specific language features while classifying the predominant paradigm and debugging code samples. The study includes both qualitative and quantitative data from 29 Python developers, including their gaze fixations during the tasks. We observed that participants seem to confuse the functional and procedural paradigms, possibly due to confusing terminology used in Python, though they do gaze at specific language features. Overall, participants took more time classifying functional code. The predominant paradigm did not affect their ability to debug code, though they gave lower confidence ratings for functional code.}, } @mastersthesis{brunner20:thesis, author = {Brunner, Rebecca}, title = {Enabling Efficient Storage of {Git} Repositories in {PAClab}}, school = {Bowling Green State University}, date = {2020-08-01}, abstract = {A current trend in the field of static analysis is to use open source platforms such as GitHub to develop benchmark program suites. These suites are used for the evaluation of static analysis tools. Programs collected from GitHub often must be transformed by hand to work with these tools. PAClab is an online platform that automatically performs code transformations to solve this problem. PAClab stores a base selection of Git projects that expand over time, creating a need to maintain multiple versions of each Git project effectively. In this work, we propose a solution to store multiple versions of a Git project efficiently in the PAClab system. We visualize Git projects as a graph, and by focusing on reducing the graph size and removing node duplication, we found filtering projects reduced the storage size of 2,955 Git projects by 96\%. Compared with a naive approach, we also found our approach utilized around 6x less space when storing a week's worth of snapshots.}, } @mastersthesis{hung19:thesis, author = {Hung, Che Shian}, title = {{Boa} Views: Enabling Modularization and Sharing of {Boa} Queries}, school = {Bowling Green State University}, date = {2019-08-01}, abstract = {The Mining Software Repositories (MSR) field is well established, and recently has seen a focus on moving analysis techniques to a larger scale analyzing thousands of projects. Several tools exist to support these efforts, such as the Boa language and infrastructure. While Boa has seen extensive use by over one thousand users, in its current form it is not always possible to perform the entire analysis task within the infrastructure, often requiring some post-processing in another language. To address this problem, we use the notion of views from the relational database field and designed a language extension and runtime infrastructure in Boa that we call materialized views. Materialized views provide output reuse to Boa users, so that the results of prior Boa queries can be reused by users. This allows for computing results not previously possible within Boa and provides more sharing and reuse of MSR queries. To evaluate views, we performed two partial reproductions of prior MSR studies utilizing Boa's dataset and infrastructure with Boa and compare our results to the prior studies. This shows the usability of the new infrastructure, allowing analyses in Boa that were not previously possible as well as providing a previously hand created gold dataset for identifier splitting as a reusable view for other MSR researchers. We also verified the caching behavior using the queries from one of the case studies. The results show that caching works as expected and can drastically improve the runtime performance.}, } @mastersthesis{arafat18:thesis, author = {Arafat, Mohd}, title = {An Investigation of Routine Repetitiveness in Open-Source Projects}, school = {Bowling Green State University}, date = {2018-08-01}, abstract = {Many programming languages contain a way to provide a sub-portion of the source code that performs a specific and often independent behavior. Depending on the language this is called a (sub-)routine, method, function, procedure, etc. One of the main purposes of creating a routine is to enable re-use. As devised, routines are intended to be called from multiple places within a program. Sometimes, however, the same code is repeated within a project or across projects. In this work, we investigate how often such routines are repeated in a large-scale corpus of open source software. This work attempts to independently reproduce a prior research result by Nguyen et al., building from the ground up the analysis framework and analyzing a different and very large set of open source software projects. In this work, we use the Boa infrastructure to investigate routine repetitiveness by analyzing over 300k open source projects from GitHub. Similar to the prior work, we first compute the program dependence graphs (PDGs) for each routine in the dataset, perform normalization on the PDGs, and look for repetitions both within and across projects. Our experiment shows that about 16.4\% of routines repeat within a project and approximately 11\% of routines repeat across at least two different projects. We then perform static program slicing on the PDGs, slicing the graph on each routine argument to obtain subroutines and look for repetitiveness once again. We observe that approximately 17\% of all subroutines repeat within a project and 11\% repeat across projects. Finally, we investigate if the size of the PDG or the number of control nodes has any impact on the repetitiveness of routines. Overall, our results confirm the trends shown in the prior study, though with differences in the size of the results.}, } @mastersthesis{shrimal16:thesis, author = {Shrimal, Shubhendra}, title = {Maximizing Parallelization Opportunities by Automatically Inferring Optimal Container Memory for Asymmetrical Map Tasks}, school = {Bowling Green State University}, date = {2016-08-01}, abstract = {The MapReduce programming model provides efficient parallel processing via two user-defined tasks: map and reduce. Input files are split into individual records and each record is processed by a single map task. Implementations of the model, such as Apache Hadoop, typically assume each record is similarly sized and thus they allocate the same memory for every map task. However, certain data sets, such as Wikipedia or the project data from SourceForge, do not follow this assumption and instead contain very asymmetrically sized records. To handle such data sets, the current state of the art solution is to determine the maximum memory requirements for the largest record and then configure the system to allocate this much memory for all map tasks. This simple solution however, decreases the maximum number of tasks running in parallel, leading to lower overall CPU utilization on the cluster. In this work, we propose three solutions to help maintain as much parallelism as possible while processing such asymmetric data sets. As our first solution we propose a fall-back approach, where initially all map tasks run with the standard allocation of memory. If any task attempt fails due to memory reasons, subsequent attempts of that task are run with twice the memory/heap of the previous attempt. This solution is fully automatic and requires no configuration of Hadoop. Our second solution allows users to manually specify specific map tasks to be allocated more memory. Thus, if users know a priori which records are larger, they can avoid letting that map task run, fail, and retry with the first approach. Our third solution is to automatically infer which map tasks have higher memory requirements, based on learning from prior runs of the same input data which tasks failed and had to fall-back with our first solution. If multiple jobs are run on the same input, this solution avoids the need for users to manually specify the tasks requiring more memory. We evaluate these approaches by measuring performance on several data sets and comparing to the state of the art solution. Our evaluation shows up to 37-48\% performance improvement for our approaches when compared to the state of the art solution, due to increased parallelism in the system, and with minimal overhead.}, } @inproceedings{dyer22:tut-mining-studies, author = {Dyer, Robert and Flint, Samuel W.}, title = {Performing Large-Scale Mining Studies: From Start to Finish (Tutorial)}, date = {2022-11-18}, isbn = {9781450394130}, publisher = {Association for Computing Machinery}, doi = {10.1145/3540250.3569448}, booktitle = {Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering}, pages = {1822}, address = {Singapore}, series = {{ESEC/FSE}}, abstract = {Modern software engineering research often relies on mining open-source software repositories, to either provide motivation for their research problems and/or evaluation of the proposed approach. Mining ultra-large-scale software repositories is still a difficult task, requiring substantial expertise and access to significant hardware. Tools such as Boa can help researchers easily mine large numbers of open-source repositories. There has also recently been more of a push toward open science, with an emphasis on making replication packages available. Building such replication packages incurs additional workload for researchers. In this tutorial, we teach how to use the Boa infrastructure for mining software repository data. We leverage Boa's VS Code IDE extension to help write and submit Boa queries, and also leverage Boa's study template to show how researchers can more easily analyze the output from Boa and automatically produce a suitable replication package that is published on Zenodo.}, } @inproceedings{upadhyaya17:tut-program-analysis, author = {Upadhyaya, Ganesha and Rajan, Hridesh and Dyer, Robert and Nguyen, Tien N.}, title = {Program Analysis on Thousands of Projects}, date = {2017-10-31}, booktitle = {Proceedings of the 32nd International Conference on Automated Software Engineering}, address = {Urbana-Champaign, IL, USA}, series = {{ASE}}, } @inproceedings{dyer15:tut-feature-mining, author = {Dyer, Robert and Rajan, Hridesh and Nguyen, Tien N. and Nguyen, Hoan Anh}, title = {Mining Programming Language Usage with {Boa}}, date = {2015-10-29}, booktitle = {Proceedings of the 6th International Conference on Systems, Programming, Languages, and Applications: Software for Humanity}, address = {Pittsburgh, PA, USA}, series = {{SPLASH}}, } @inproceedings{dyer14:tut-boa, author = {Dyer, Robert and Rajan, Hridesh and Nguyen, Tien N. and Nguyen, Hoan Anh}, title = {Efficiently Mining Source Code with {Boa}}, date = {2014-06-02}, booktitle = {Proceedings of the 36th International Conference on Software Engineering}, address = {Hyderabad, India}, series = {{ICSE}}, } @inproceedings{dyer13:tut-boa, author = {Dyer, Robert and Rajan, Hridesh}, title = {Mining Ultra-Large-Scale Software Repositories with {Boa}}, date = {2013-10-30}, booktitle = {Proceedings of the 4th International Conference on Systems, Programming, Languages, and Applications: Software for Humanity}, address = {Indianapolis, IN, USA}, series = {{SPLASH}}, } @inproceedings{rajan11b:tut-ptolemy, author = {Rajan, Hridesh and Leavens, Gary T. and Dyer, Robert}, title = {Modularizing Crosscutting Concerns with {Ptolemy}}, date = {2011-11-08}, booktitle = {Proceedings of the 26th International Conference on Automated Software Engineering}, address = {Lawrence, KS, USA}, series = {{ASE}}, } @inproceedings{rajan11:tut-ptolemy, author = {Rajan, Hridesh and Leavens, Gary T. and Dyer, Robert and Bagherzadeh, Mehdi}, title = {Modularizing Crosscutting Concerns with {Ptolemy}}, date = {2011-03-22}, isbn = {9781450306065}, publisher = {Association for Computing Machinery}, doi = {10.1145/1960314.1960332}, booktitle = {Proceedings of the Tenth International Conference on Aspect-Oriented Software Development Companion}, pages = {61-62}, address = {Porto de Galinhas, Brazil}, series = {{AOSD}}, abstract = {This tutorial will provide an introduction to Ptolemy. Ptolemy is a programming language whose goals are to improve a software engineer's ability to separate conceptual concerns, while preserving encapsulation of object-oriented code and the ability of programmers to modularly reason about their code. In particular, Ptolemy's features are useful towards modularization of cross-cutting concerns. A cross-cutting concern is a requirement whose implementation is spread across and mixed with the code of other requirements. There has been attempts to improve separation of cross-cutting concerns, e.g. by aspect oriented and implicit-invocation languages, but none give software developers textual separation of concerns and modular reasoning at the same time. Ptolemy has both these properties important for scalable software engineering. Ptolemy's event types provide a well-defined interface between object-oriented code and cross-cutting code. This in turn enables separate type-checking and compilation. Ptolemy also provides a novel and practical specification mechanism that we call translucid contracts. A translucid contracts allows developers to reason about the control effects of the object-oriented code and cross-cutting code modularly. This tutorial will proceed by discussing the goals of the Ptolemy programming language. We will then discuss Ptolemy's programming features and its specification features by way of several hands-on exercises. We will conclude with pointers to ongoing work on design, implementation and verification of Ptolemy programs.}, } @inproceedings{nguyen18:usage-mining-preconditions, author = {Nguyen, Hoan Anh and Nguyen, Tien N. and Rajan, Hridesh and Dyer, Robert}, title = {Towards Combining Usage Mining and Implementation Analysis to Infer {API} Preconditions}, date = {2018-11-09}, isbn = {9781450360579}, publisher = {Association for Computing Machinery}, doi = {10.1145/3278177.3278182}, booktitle = {Proceedings of the 1st ACM SIGSOFT International Workshop on Automated Specification Inference}, pages = {15-16}, address = {Lake Buena Vista, FL, USA}, series = {{WASPI}}, abstract = {The preconditions of an API method are constraints on the states of its receiver object and arguments intended by the library designer(s) to correctly invoke it in the client code. There have been two main kinds of approaches for automatically inferring API preconditions. The first kind of approaches mines the frequently checked conditions guarding the API usages in the client code and generalize them into preconditions. The second kind of approaches analyzes the implementation of the API to compute preconditions. In this paper, we report an observation that the usage-based approach often produces preconditions stronger than those intended while the implementation-based produces weaker ones. Our finding calls for a new direction of integrating those kinds of precondition inference approaches and refinement solutions to reduce the differences between sets of inferred preconditions.}, } @inproceedings{shakiba16:fourd, author = {Shakiba, Abbas and Green, Robert and Dyer, Robert}, title = {{FourD}: Do Developers Discuss Design? Revisited}, date = {2016-11-13}, isbn = {9781450343954}, publisher = {Association for Computing Machinery}, doi = {10.1145/2989238.2989244}, booktitle = {Proceedings of the 2nd International Workshop on Software Analytics}, pages = {43-46}, address = {Seattle, WA, USA}, series = {{SWAN}}, abstract = {Software repositories contain a variety of information that can be mined and utilized to enhance software engineering processes. Patterns stored in software repository meta-data can provide useful and informative information about different aspects of a project, particularly those that may not be obvious for developers. One such aspect is the role of software design in a project. The messages connected to each commit in the repository note not only what changes have been made to project files, but potentially if those changes have somehow manipulated the design of the software. In this paper, a sample of commit messages from a random sample of projects on GitHub and SourceForge are manually classified as "design" or "non-design" based on a survey. The resulting data is then used to train multiple machine learning algorithms in order to determine if it is possible to predict whether or not a single commit is discussing software design. Our results show the Random Forest classifier performed best on our combined data set with a G-mean of 75.01.}, } @inproceedings{fernando12:event-polymorphism, author = {Fernando, Rex D. and Dyer, Robert and Rajan, Hridesh}, title = {Event Type Polymorphism}, date = {2012-03-26}, isbn = {9781450310994}, publisher = {Association for Computing Machinery}, doi = {10.1145/2162010.2162020}, booktitle = {Proceedings of the 11th Workshop on Foundations of Aspect-Oriented Languages}, pages = {33-38}, address = {Potsdam, Germany}, series = {{FOAL}}, abstract = {Subtype polymorphism is an important feature available in most modern type systems which makes code reuse and specialization possible. Recent works on separation of crosscutting concerns have created event interfaces (types) to decouple subjects from handlers. Extending the notion of subtyping to these event interfaces is a logical step. In this paper, we define event type polymorphism in the context of the Ptolemy language. Ptolemy allows declaring quantified, typed events which provide an interface between subjects and handlers. We add the notion of polymorphic event types to the Ptolemy language, defining a subtype relation among event types which in turn allows for both depth and width subtyping with regard to event context. Since Ptolemy only has explicit event announcement, our semantics is simpler and easier to reason about when compared to previously defined approaches. We also give the first formally defined static semantics for polymorphic events as well as demonstrate its usefulness via examples.}, } @inproceedings{bagherzadeh11:translucid-contracts, author = {Bagherzadeh, Mehdi and Leavens, Gary T. and Dyer, Robert}, title = {Applying Translucid Contracts for Modular Reasoning about Aspect and Object Oriented Events}, date = {2011-03-21}, isbn = {9781450306447}, publisher = {Association for Computing Machinery}, doi = {10.1145/1960510.1960517}, booktitle = {Proceedings of the 10th International Workshop on Foundations of Aspect-Oriented Languages}, pages = {31-35}, address = {Porto de Galinhas, Brazil}, series = {{FOAL}}, abstract = {The Implicit Invocation (II) architectural style improves modularity and is promoted by aspect-oriented (AO) languages and design patterns like Observer. However, it makes modular reasoning difficult, especially when reasoning about control effects of the advised code (subject). Our language Ptolemy, which was inspired by II languages, uses translucid contracts for modular reasoning about the control effects; however, this reasoning relies on Ptolemy's event model, which has explicit event announcement and declared event types. In this paper we investigate how to apply translucid contracts to reasoning about events in other AO languages and even non-AO languages like C\#.}, } @inproceedings{dyer10:typed-events, title = {A preliminary study of quantified, typed events}, author = {Dyer, Robert and Bagherzadeh, Mehdi and Rajan, Hridesh and Cai, Yuanfang}, booktitle = {Empirical Evaluation of Software Composition Techniques, A workshop affiliated with AOSD}, series = {{ESCOT}}, date = {2010-03-16}, address = {Rennes and Saint-Malo, France}, } @inproceedings{baelen10:feature-volatility, author = {Warren Baelen and Yuanfang Cai and Robert Dyer and Hridesh Rajan}, title = {Feature Volatility Assessment}, date = {2010-09-13}, booktitle = {14th International Conference on Software Product Lines, Volume 2}, series = {{SPLC}}, pages = {33-34}, publisher = {Lancaster University}, address = {Jeju Island, South Korea}, } @inproceedings{dyer08:decision-tree-pointcuts, author = {Dyer, Robert and Rajan, Hridesh}, title = {A Decision Tree-Based Approach to Dynamic Pointcut Evaluation}, date = {2008-10-19}, isbn = {9781605583846}, publisher = {Association for Computing Machinery}, doi = {10.1145/1507504.1507508}, booktitle = {Proceedings of the 2nd Workshop on Virtual Machines and Intermediate Languages for Emerging Modularization Mechanisms}, articleno = {4}, numpages = {10}, address = {Nashville, TN, USA}, series = {{VMIL}}, abstract = {Constructs of dynamic nature, e.g., history-based pointcuts and control-flow based pointcuts, have received significant attention in recent aspect-oriented literature. A variety of compelling use cases are presented that motivate the need for efficiently supporting such constructs in language implementations. The key challenge in implementing dynamic constructs is to efficiently support runtime adaptation of the set of intercepted join points at a fine-grained level. This translates to two high-level requirements. First, since the set of intercepted join points may change, such implementations must provide an efficient method to determine this set membership, i.e., whether the currently executing join point needs to be intercepted. Second, the frequency with which such set membership needs to be determined must be minimized. In previous work, Dyer and Rajan proposed a dedicated caching mechanism to address the second requirement. In this work, we propose a mechanism to address the first requirement. This requirement translates to efficiently evaluating whether a join point is intercepted by a set of pointcut expressions. In the worst case, at every join point there may be the need to determine whether it is intercepted. Therefore, even modest savings in such mechanisms is likely to translate to significant savings in the long run.}, } @inproceedings{rajan06:preserving-soc, author = {Rajan, Hridesh and Dyer, Robert and Hanna, Youssef and Narayanappa, Harish}, title = {Preserving separation of concerns through compilation}, booktitle = {Software Engineering Properties of Languages and Aspect Technologies, A workshop affiliated with AOSD}, date = {2006-03-21}, series = {{SPLAT}}, address = {Bonn, Germany}, }