While lots of research has explored how to prevent maintainers from abandoning the open-source projects that serve as our digital infras- tructure, there are very few insights on addressing abandonment when it occurs. We argue open-source sustainability research must expand its focus beyond trying to keep particular projects alive, to also cover the sustainable use of open source by supporting users when they face potential or actual abandonment. We interviewed 33 developers who have experienced open-source dependency aban- donment. Often, they used multiple strategies to cope with aban- donment, for example, first reaching out to the community to find potential alternatives, then switching to a community-accepted alternative if one exists. We found many developers felt they had little to no support or guidance when facing abandonment, leaving them to figure out what to do through a trial-and-error process on their own. Abandonment introduces cost for otherwise seem- ingly free dependencies, but users can decide whether and how to prepare for abandonment through a number of different strategies, such as dependency monitoring, building abstraction layers, and community involvement. In many cases, community members can invest in resources that help others facing the same abandoned dependency, but often do not because of the many other competing demands on their time – a form of the volunteer’s dilemma. We dis- cuss cost reduction strategies and ideas to overcome this volunteer’s dilemma. Our findings can be used directly by open-source users seeking resources on dealing with dependency abandonment, or by researchers to motivate future work supporting the sustainable use of open source.

“We Feel Like We’re Winging It:” A Study on Navigating Open-Source Dependency Abandonment

Instruction sequences with direct and indirect jump instructions are as expressive as instruction sequences with direct jump instructions only. We show that, in the case where the number of instructions is not bounded, we are faced with increases of the maximal internal delays of instruction sequences on execution that are not bounded by a linear function if we strive for acceptable increases of the lengths of instruction sequences on elimination of indirect jump instructions.

Indirect jumps improve instruction sequence performance

Software undergoes constant changes to support new requirements, address bugs, enhance performance, and ensure maintainability. Thus, developers spend a great portion of their workday trying to understand and review the code changes of their teammates. Abstract Syntax Tree (AST) diff tools were developed to overcome the limitations of line-based diff tools, which are used by the majority of developers. Despite the notable improvements brought by AST diff tools in understanding complex changes, they still suffer from serious limitations, such as (1) lacking multi-mapping support, (2) matching semantically incompatible AST nodes, (3) ignoring language clues to guide the matching process, (4) lacking refactoring awareness, and (5) lacking commit-level diff support. We propose a novel AST diff tool based on RefactoringMiner that resolves all aforementioned limitations. First, we improved RefactoringMiner to increase its statement mapping accuracy, and then we developed an algorithm that generates AST diff for a given commit or pull request based on the refactoring instances and pairs of matched program element declarations provided by RefactoringMiner. To evaluate the accuracy of our tool and compare it with the state-of-the-art tools, we created the first benchmark of AST node mappings, including 800 bug-fixing commits and 188 refactoring commits. Our evaluation showed that our tool achieved a considerably higher precision and recall, especially for refactoring commits, with an execution time that is comparable with that of the faster tools. 

A Novel Refactoring and Semantic Aware Abstract Syntax Tree Differencing Tool and a Benchmark for Evaluating the Accuracy of Diff Tools

In today's software industry, large-scale, multi-language codebases are the norm. This brings substantial challenges in developing automated tools for code maintenance tasks such as API migration or dead code cleanup. Tool builders often find themselves caught between two less-than-ideal tooling options: (1) language-specific code rewriting tools or (2) generic, lightweight match-replace transformation tools with limited expressiveness. The former leads to tool fragmentation and a steep learning curve for each language, while the latter forces developers to create ad-hoc, throwaway scripts to handle realistic tasks. To fill this gap, we introduce a new declarative domain-specific language (DSL) for expressing interdependent multi-language code transformations. Our key insight is that we can increase the expressiveness and applicability of lightweight match-replace tools by extending them to support for composition, ordering, and flow. We implemented an open-source tool for our language, called PolyglotPiranha, and deployed it in an industrial setting. We demonstrate its effectiveness through three case studies, where it deleted 210K lines of dead code and migrated 20K lines, across 1611 pull requests. We compare our DSL against state-of-the-art alternatives, and show that the tools we developed are faster, more concise, and easier to maintain. 

A Lightweight Polyglot Code Transformation Language

For software maintenance and evolution, insight into the codebase is crucial. One way to enhance insight is the application of static analysis to extract and visualize program-specific relations from the code itself, such as call graphs and inheritance trees. Yet, software often contains in-house libraries: unique, domain-specific libraries whose usage is typically scattered throughout the codebase. To provide sufficient insight into the usage of those libraries, the static analysis must be customized with domain-specific information. In this paper, we propose a method to enhance insight into the usage of in-house libraries by producing custom overviews. Furthermore, we describe three exploratory case studies targeting industrial C++ and Ada codebases, in which the method was developed, evolved, and validated. The method prescribes how to create custom overviews using static analysis iteratively, starting from a user-provided, initial specification of proper library usage using code patterns. As a safeguard, the method includes cross-checks to detect code fragments that deviate from proper library usage. Whenever such a deviating library usage is found, the code owners determine whether that deviating library usage should be added to the specification of proper library usage or the code fragment should be made compliant. The latter alternative makes both the codebase more regular and keeps the custom static analysis simpler. The method creates custom overviews that reveal opportunities to improve the usage of the in-house libraries, e.g., the removal of domain-specific redundant code which cannot be detected using generic tools, such as compilers and linters. We observed that industrial codebases are regular enough to create custom overviews using static analysis in the three exploratory case studies. Furthermore, we observed that the cross-checks, which detect deviating library usage, ensure the validity and completeness of the custom overviews. We conclude that producing custom overviews for in-house libraries using the method is valuable and feasible. 

Custom static analysis to enhance insight into the usage of in-house libraries

PGA, short for ProGram Algebra, describes sequential programs as finite or infinite (repeating) sequences of instructions The semigroup C of finite instruction sequences was introduced as an equally expressive alternative to PGA PGA instructions are executed from left to right; most C instructions come in a left-to-right as well as a right-to-left flavor This thesis builds on C by introducing an alternative semigroup Cg which employs label and goto instructions instead of relative jump instructions as control structures Cg can be translated to C and vice versa (and is thus equally expressive) It is shown that restricting the instruction sets of C and Cg to contain only finitely many distinct jump, goto or label instructions in either or both directions reduces their expressiveness Instruction sets with an infinite number of these instructions in both directions (not necessarily all such instructions) do not suffer a loss of expressiveness

Expressiveness and Extensions of an Instruction Sequence Semigroup

Software projects use a significant number of external libraries to speed up development and deliver high-quality software in a cost-effective way. Requirements placed on external libraries can change over time and libraries may cease to be maintained or evolve in incompatible ways. Consequently, a library may no longer be fit for purpose and require replacement. Such a library migration is generally performed manually and may be complex, error-prone, and time-consuming, especially for large codebases. It follows that an automated approach to library migrations is preferred. We consider the suitability of Error Prone and Refaster, two Google tools capable of refactoring Java programs, for automated library migration. For validation we consider a migration in a proprietary industrial codebase as well as an actively developed open source codebase. We show that using out-of-the-box Error Prone and Refaster full migration of RxJava 2-referencing files is possible in only 35% and 0% of such files, respectively. To increase the capabilities and be able to migrate more Rx-Java 2-referencing files completely, we create extensions to Error Prone and Refaster. Therefore we propose and create extensions that improve the accuracy with which Refaster templates are matched, as well as the correctness of their replacement operations. We additionally propose a set of Error Prone extensions to facilitate rewriting method return types. Together they enable a new class of rewrite operations especially relevant to library migrations. Lastly, several generalizations and improvements of existing Error Prone plugins are discussed. Together these improvements enable a new class of rewrite operations, especially relevant to library migrations. Using the proposed extensions, we manage to fully migrate an additional 35% of the RxJava 2-referencing files in the industrial codebase, and an initial 39% of such files in the open source codebase.

Automating Library Migrations with Error Prone and Refaster

Software projects use a significant number of external libraries to speed up development and deliver high-quality software in a cost-effective way. Requirements placed on external libraries can change over time and libraries may cease to be maintained or evolve in incompatible ways. Consequently, a library may no longer be fit for purpose and require replacement. Such a library migration is generally performed manually and may be complex, error-prone, and time-consuming, especially for large codebases. It follows that an automated approach to library migrations is preferred. We consider the suitability of Error Prone and Refaster, two Google tools capable of refactoring Java programs, for automated library migration. We propose extensions that improve the accuracy with which Refaster templates are matched, as well as the correctness of their replacement operations. We additionally propose a set of Error Prone extensions to facilitate rewriting method return types. Together they enable a new class of rewrite operations especially relevant to library migrations. For validation we consider a private industrial codebase as well as an actively developed open source codebase. We show that using out-of-the-box Error Prone and Refaster full migration of RxJava 2-referencing files is possible in only 35% and 0% of such files, respectively. Using the proposed extensions, we manage to fully migrate an additional 35% of the RxJava 2-referencing files in the former codebase, and an initial 39% of such files in the latter codebase.

Towards automated library migrations with error prone and refaster

Handle everyday research tasks with reliable, citation-backed results

Your personal Research Agent to handle research tasks with citation-backed results

Popular Tasks used by Researchers

How can I help with your research?

Meet SciSpace

Get more enhanced response by uploading the PDFs you want me to reference.

No relevant PDFs in your library

SciSpace is the AI research assistant for academics. Run systematic literature reviews on 280M+ papers, and write papers with cited sources. Trusted by 1M+ students, PhDs & researchers.

SciSpace | AI for Research

Analyze PDFs

Code & Manuscripts

Funding & Grants

Literature & Patents

Medical & Clinical Data

Systematic Review

Visualize & Present

Web & Data

Build a Google Scholar-like website for your research.

Build a website

Create charts and images for your research

Create a Chart

Write a paper for submission to a journal

Draft a manuscript

Patent Search

Design eye-catching scientific posters in minutes.

Scientific Poster Generation

Systematic Literature Review

One task is running at the moment. Your messages will be shown right after.

Drag and drop or click here to browse

Loved by <highlight>1 million+</highlight> researchers

Extract a list of specific topics and their sources from unstructured text

Topics

Compare and analyze relevant papers that matches with your search

Papers

Get insights from PDFs and bookmarked papers from your library

My library

Recent searches

Try searching for:

Catch AI-generated content in scholarly and non-scholarly content

{ai} Detector

Ai Writer

Get PDF Summaries, highlighted text explanations 

Chat with PDF

Effortlessly create in-text citations and bibliographies in APA and 2,500 other formats

Citation generator

Get explanations, summaries, and answers on academic papers

Ease up your research workflow with {scispace}'s cohort of exciting AI tools

Elevate your academic writing skills and convey your ideas the way you want

Paraphraser

Explore our range of reading and writing tools

Your file is being prepared and should be ready in a few minutes. If it's a large file, it might take a bit longer. You can close this window, and we'll email you the file when it's done.

You have reached a maximum limit of <strong>{limit}</strong> columns in the table. Remove at least <strong>1</strong> column to add or create another one.

Stephan Schroevers

Author Tools

Chat about Author

Papers

Expressiveness and Extensions of an Instruction Sequence Semigroup

Automating Library Migrations with Error Prone and Refaster

Towards automated library migrations with error prone and refaster