Andrew Macvean
Andrew has been at Google since July 2014, conducting research into developer experience. He is interested in the usability of web APIs, Client Libraries, and developer documentation.
Research Areas
Authored Publications
Google Publications
Other Publications
Sort By
Preview abstract
ML enhanced software development tooling is changing the way software engineers develop code. While the development of these tools continues to rise, studies have primarily focused on the accuracy and performance of underlying models, rather than the user experience. Understanding how engineers interact with ML enhanced tooling can help us define what successful interactions with ML based assistance look like. We therefore build upon prior research, by comparing software engineers' perceptions of two types of ML enhanced tools, (1) code completion and (2) code example suggestions. We then use our findings to inform design guidance for ML enhanced software development tooling. This research is intended to spark a growing conversation about the future of ML in software development and guide the design of developer tooling.
View details
Understanding How Programmers Can Use Annotations on Documentation
Amber Horvath
Michael Xieyang Liu
River Hendriksen
Connor Shannon
Emma Paterson
Kazi Jawad
Brad A. Myers
In CHI Conference on Human Factors in Computing Systems (CHI '22), April 29-May 5, 2022, New Orleans, LA, USA. ACM, New York, NY, USA 16 Pages (2022)
Preview abstract
Modern software development requires developers to find and effectively utilize new APIs and their documentation, but documentation has many well-known issues. Despite this, developers eventually overcome these issues but have no way of sharing what they learned. We investigate sharing this documentation-specific information through annotations, which have advantages over developer forums as the information is contextualized, not disruptive, and is short, thus easy to author. Developers can also author annotations to support their own comprehension. In order to support the documentation usage behaviors we found, we built the Adamite annotation tool, which provides features such as multiple anchors, annotation types, and pinning. In our user study, we found that developers are able to create annotations that are useful to themselves and are able to utilize annotations created by other developers when learning a new API, with readers of the annotations completing 67% more of the task, on average, than the baseline.
View details
Accessibility of Command Line Interfaces
CHI Conference on Human Factors in Computing Systems (2021)
Preview abstract
Command line interfaces (CLIs) remain a popular tool among developers and system administrators. Since CLIs are text based interfaces, they are sometimes considered accessible alternatives to predominantly visual developer tools like IDEs. However, there is no systematic evaluation of accessibility of CLIs in the literature. In this paper, we describe two studies with 12 developers on their experience of using CLIs with screen readers. Our findings show that CLIs have their own set of accessibility issues - the most important being CLIs are unstructured text interfaces. Based on our findings, we provide a set of recommendations for improving accessibility of command line interfaces.
View details
MARBLE: Mining for Boilerplate Code to Identify API Usability Problems
Daye Nam
Amber Horvath
Bogdan Vasilescu
Brad A. Myers
Proceedings 34th IEEE/ACM International Conference on Automated Software Engineering (2019)
Preview abstract
Designing usable APIs is critical to developers’ productivity and software quality, but is quite difficult. One of the challenges is that anticipating API usability barriers and real world usage is difficult, due to a lack of automated approaches to mine usability data at scale. In this paper, we focus on one particular grievance that developers repeatedly express in online discussions about APIs: “boilerplate code.” We investigate what properties make code count as boilerplate, the reasons for boilerplate, and how programmers can reduce the need for it. We then present MARBLE, a novel approach to automatically mine boilerplate code candidates from API client code repositories. MARBLE adapts existing techniques, including an API usage mining algorithm, an AST comparison algorithm, and a graph partitioning algorithm. We evaluate MARBLE with 13 Java APIs, and show that our approach successfully identifies both already known and new API-related boilerplate code instances.
View details
Discovering API Usability Problems at Scale
Andrew Head
International Workshop on API Usage and Evolution (WAPI) (2018)
Preview abstract
Software developers’ productivity can be negatively impacted by using APIs incorrectly. In this paper, we describe an analysis technique we designed to find API usability problems by comparing successive file-level changes made by individual software developers. We applied our tool, StopMotion, to the file histories of real developers doing real tasks at Google. The results reveal several API usability challenges including simple typos, conceptual API misalignments, and conflation of similar APIs.
View details
API Designers in the Field: Design Practices and Challenges for Creating Usable APIs
Lauren Murphy
Mary Beth Kery
Tosin Alliyu
Brad A. Myers
2018 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC'18)
Preview abstract
Application Programming Interfaces (APIs) are a rapidly growing industry and the usability of the APIs is crucial to programmer productivity. Although prior research has shown that APIs commonly suffer from significant usability problems, little attention has been given to studying how APIs are designed and created in the first place. We interviewed 24 professionals involved with API design from 7 major companies to identify their training and design processes. Interviewees had insights into many different aspects of designing for API usability and areas of significant struggle. Even though use cases are central to the design of APIs, during the design phase it is challenging to discern which potential use cases of the API users will value most. After an API is released, designers lack tools to gather any feedback from this data in aggregate even as developers openly discuss the API online.
View details
Preliminary Analysis of REST API Style Guidelines
Lauren Murphy
Tosin Alliyu
Mary Beth Kery
Brad A. Myers
8th Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU'2017) at SPLASH 2017 (2017)
Preview abstract
We studied a collection of 32 publicly published guidelines for designing RESTful Application Programming Interfaces (APIs), each from a different company, to identify similarities and differences to see if there are overall best practices across ten different topics. Our contribution includes providing a list of topics that API authors can reference when creating or evaluating their own guidelines. Additionally, we found that while some guidelines attempt to enforce consistency, simplicity, and intuitiveness in the APIs that use these guidelines, cross-guideline comparisons show a lack of consistency in some of the topics examined, and different interpretations of what is thought to be “simple” and “intuitive.”
View details
The Uses of Interactive Explorers for Web APIs
Luke Church
8th Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU'2017) at SPLASH 2017, ACM
Preview abstract
Interactive method invocation has become a common interaction pattern in the documentation of web application programming interfaces (APIs). One of the earliest examples of this pattern being applied at scale is the Google APIs Explorer. In this paper, we describe eight ways developers use such tools in software development, grounded on empirical analyses of the Google APIs Explorer. We then explain the utility of these tools by tying the use cases back to extant literature on programming.
View details
API Usability at Scale
Luke Church
Craig Citro
Proceedings of the 26th annual workshop of the Psychology of Programming Interest Group (2016)
Preview abstract
Designing and maintaining useful and usable APIs remains challenging. At Google we manage hundreds of APIs. In this article we report on the experience of doing so and describe six on-going challenges: resource allocation, empirically-grounded guidelines, communicating issues, supporting API evolution over time, usable auth, and usable client libraries at scale.
View details
API Design Reviews at Scale
Martin Maly
CHI EA '16 Proceedings of the 2016 CHI Conference Extended Abstracts on Human Factors in Computing Systems, ACM New York, NY, USA, pp. 849-858
Preview abstract
The number of APIs produced by Google's various business units grew at an astounding rate over the last decade, the result of which was a user experience containing wild inconsistencies and usability problems. There was no single issue that dominated the usability problems; rather, users suffered a death from a thousand papercuts. A lightweight, scalable, distributed design review process was put into place that has improved our APIs and the efficacy of our many API designers. Challenges remain, but the API design reviews at scale program has started successfully.
View details
No Results Found