Jump to Content
Andrew Macvean

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.
Authored Publications
Google Publications
Other Publications
Sort By
  • Title
  • Title, descending
  • Year
  • Year, descending
    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
    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
    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
    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
    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
    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
    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
    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
    No Results Found