Opportunities in Software Engineering Research for Web API Consumption

TL;DR

This paper discusses the challenges of consuming web APIs in software engineering and proposes research opportunities, including API specification curation and static analysis, to improve developer support and IDE integration.

Contribution

It introduces new research directions in web API specification curation and static analysis, and demonstrates combining these for enhanced IDE support.

Findings

Identification of key challenges in web API consumption

Proposal of methods for API specification curation and static analysis

Initial work on integrating these methods into IDE support

Abstract

Nowadays, invoking third party code increasingly involves calling web services via their web APIs, as opposed to the more traditional scenario of downloading a library and invoking the library's API. However, there are also new challenges for developers calling these web APIs. In this paper, we highlight a broad set of these challenges and argue for resulting opportunities for software engineering research to support developers in consuming web APIs. We outline two specific research threads in this context: (1) web API specification curation, which enables us to know the signatures of web APIs, and (2) static analysis that is capable of extracting URLs, HTTP methods etc. of web API calls. Furthermore, we present new work on how we combine (1) and (2) to provide IDE support for application developers consuming web APIs. As web APIs are used broadly, research in supporting the consumption of web APIs offers exciting opportunities.

Full text

I Introduction

Programmers write applications using a growing variety of publicly accessible web services, or by interacting with dedicated, private backends. Applications typically consume both, these services and backends, using web APIs – application programming interfaces invoked over network that rely on web technologies like HTTP as a transport protocol or XML and JSON as data formats. In practice, these APIs are often ”REST-like”, in that they adhere to some of the constraints imposed by the Representational State Transfer (REST) architectural style [1]. The extent of the proliferation of web APIs is indicative in the thousands of web APIs listed in catalogs such as IBM’s API Harmony [2], Mashape’s PublicAPIs [3], or ProgrammableWeb [4].

For developers, consuming web APIs poses many challenges, compared to that of traditional library APIs, including:

• •

Challenge 1: Clients have the guarantee that once they download a traditional library, they have control over the API and the code being called. However, web APIs clients have no control over the API and the service behind the API, as a provider may change either or both.

• •

Challenge 2: Clients of a local library can depend on a compiler to check whether a call conforms to the library interface. Clients of web APIs, in contrast, do not know whether the signature of a call—i.e., the URL, the request payload, query parameters—is valid until run-time.111Though, there are frameworks for remote procedure calls, e.g., Thrift [5].

• •

Challenge 3: Even when clients invoke a web service via a software development kit (SDK), the SDK is essentially a wrapper that ultimately sends requests via the web API. A web API call in an SDK can get out of synchronization with the actual web API, a even more likely concern with third-party SDKs.

• •

Challenge 4: Invoking web services opens a range of issues concerning remote calls, including asynchrony, service availability, service latency and more generally, quality of service (QoS) issues. Handling these issues may require additional client code and/or restructuring of the architecture.

These and similar challenges have rarely been addressed in software engineering research, especially comparing to the vast amount on research on more traditional library APIs [6]. In our opinion, the lack of research to support the consumption of web APIs is surprising, given the broad usage of web APIs.

In this paper, we argue for research in software engineering to support consumption of web APIs.222There are also many opportunities to support the provisioning of web APIs, which is not the focus of this paper. In section II, we outline our vision of such research and state concrete research opportunities. Next, we present two examples of such research efforts. First, in section III, we discuss work on web API specification curation, which enables us to know the signatures of web APIs [7]. Second, in section IV, we discuss work on static analysis that is capable of extracting web API calls from source code, including URLs, HTTP methods, and request data [8]. Furthermore, in section V, we demonstrate the practical significance of such research by presenting a novel IDE integration tying together these two efforts, for warning a programmer of possible errors in the web APIs calls in their JavaScript code, directly addressing the aforementioned Challenge 2. Section VI concludes.

II Our vision in Web API Research

We envision that a first line of research relates to static analysis and IDE support for developers writing code containing web API calls. Some examples include the following:

• •

Detect errors in source code invoking web APIs, e.g., by statically checking that requests (comprising possibly the URL, HTTP method, query parameters, a request payload) match APIs’ requirements (our work [8], describe in Section IV). Provide developer support in IDEs, e.g., for error checking (Section IV) and auto-completion.

• •

Provide refactoring support, for example to help developers to migrate to new web API versions, similar to efforts for traditional APIs, e.g., [9, 10].

• •

Mine web API usage for more advanced developer support, e.g., recommending effective web API usage patterns, provisioning code snippets or even recommending effective composition of APIs, similar to such efforts for traditional library APIs, for which Robillard et al. provides an extensive survey [6].

Another line of research involves mechanisms to document a web API’s signatures; interfaces of web APIs are not automatically available to clients, unlike in traditional library APIs where the API is part of a library’s signatures. The API’s signatures are needed, e.g., for the aforementioned error checking and version migration. Machine-readable API specifications have been proposed, like the OpenAPI specification [11]. However, these specifications are not necessarily available. A promising research area is as follows:

• •

Support the curation of web API specifications, e.g., the OpenAPI specification [11]. Research can address how to automatically create, maintain, or test such specifications (Section III).

Because of the nature of web API calls, clients need additional software engineering support, posing opportunities of research, including:

• •

Research coding practices and patterns for an application to deal with varying QoS, especially if used from different geographic locations [12].

• •

Assess the impact of web API usage on non-functional aspects. E.g., network usage is found to be the major consumer of battery life in mobile applications [13], and security and privacy concerns raised by the usage of external services are of high priority to users [14].

To reap such opportunities, researchers in this new field of supporting web API consumption have many technical opportunities in addressing web APIs. They include requests being made asynchronously over the network, mostly using untyped and stringified data (e.g., our static analysis in Section IV), the lack of web API specifications (e.g., our work in automatically generating specifications in Section III), or that web APIs are commonly used from dynamic languages, e.g., JavaScript, a primary language supported by browsers.

III Curation of Web API Specifications

A first line of research addresses the automatic creation and maintenance of web API specifications, which are a required input for many mechanisms to support web API consumption. As we will also do in Section IV, we start by motivating this work, then summarizing our research in this area, and providing advice for how such research can be evaluated.

III-A Problem Motivation

Web APIs do not per default expose descriptions of their interfaces to clients (cf. Challenge 2 in Section I). Rather, developers have to familiarize with individual endpoints using human-readable documentation. The lack of machine-readable interface descriptions limits the creation of capabilities like static request checking (as we will see in Section IV), auto-completion, refactoring support, automatic testing, or API composition support.

To address this shortcoming, various web API specification or description formats exist, like the aforementioned OpenAPI specification [11] (previously known as Swagger), the web application description language (WADL) [15], or the RESTful API Modeling Language (RAML) [16]. These formats describe aspects concerning the whole API like authentication or security, as well as information about individual endpoints, including the data required to send in requests and the responses to expect. Despite the existence of API specification formats, they are rarely available to developers in practice, especially for public APIs. Third-party efforts that create and maintain specifications of popular APIs like APIs Guru [17], which rely on API-specific mining facilities and contributions from the open source community, exemplify this sparsity.

The problem this line of research is concerned with is to automate the creation and maintenance of such specifications.

III-B Challenges and Possible Solutions

A straight-forward solution to address the lack of API specifications is to create them as part of web API provisioning efforts. Indeed, API management solutions that aim to help providing APIs like IBM’s API Connect [18] rely on having a specification upfront or entering a comparable set of information through graphical user interfaces (from which later a specification can be exported). Similarly, web API specifications can be created using source code annotations, e.g. [19, 20]. However, both approaches require manual effort (especially for legacy APIs) for initially creating and for maintaining specifications. Also, they depend upon API providers spending efforts, as consumers have no access to the API source code or operations.

To automate specification creation and maintenance, research has looked into inferring specifications from dynamic server traces [7] or from observed HTTP requests [21]. Beyond these efforts, possible directions to look into include inferring specifications from human-readable documentation, or from API usage mined from open source repositories (cf. Section IV-C). If working, these approaches would require less or even no manual effort, and could be used to keep specifications in sync with API implementations. However, sparse input data is a main challenge for such approaches. Usage data, for example, only helps to learn about parts of web APIs that are actually used, leaving the risk of incomplete specifications. If requests are encrypted, request and response payloads are not available. Also, many web APIs feature endpoints that can best be described with path templates. In them, dynamic URL segments that depend on user input or runtime parameters are explicitly denoted, for example username in .../user/{username}/profile. However, input data like dynamic traces only contains concrete request instances like .../user/erik/profile. The resulting challenge, thus, is to infer more generic API specifications from (few) examples. An example on how to address this challenge is our previous work on inferring specifications from dynamic traces, where we attempted solving this problem using machine-learning techniques [7].

III-C Evaluation and Relevance to Web API Researchers

To evaluate the curation of web API specifications, publicly available specifications can act as ground-truth, e.g. [17]. As further input data, web API usages can be obtained from open source repositories like GitHub. Human-readable API documentation pages are made available by most large API providers. In our previous work, we obtained real-world usage of IBM’s Watson APIs for one month and compared inferred specifications against the human-written specifications of said APIs [7]. Specifications are central to many other research opportunities, amplifying the importance of this line of research.

IV Static Analysis on Web API Calls

A second line of research addresses the lack of support for statically checking web API calls in JavaScript code [8].

IV-A Problem Motivation

To invoke a web API, applications can send HTTP requests to a dedicated URL using one of its supported HTTP methods; required data is sent as query or path parameters, or within the HTTP request body. The URL, HTTP method, and data to send are strings possibly constructed by string operations within the applications. Figure 1 shows an exemplary excerpt of a JavaScript application performing these actions. When a request targets a URL that does not exist or sends data that does not comply with the requirements of the web API, a run-time error occurs. This prevalent calling mechanism for web APIs does not allow type-safety checking. In other words, checks for traditional compile-time errors are not available for programmers writing code calling web APIs.

IV-B Our Approach and Relevance to Web API Researchers

To address this problem, we are working on a static checker that takes as input OpenAPI specifications, and then statically checks whether the web API requests in JavaScript code conform to these specifications. This solution embodies two technical challenges relevant to other researchers in the web API reseach field:

• •

Our approach has to be able to extract requests which are strings (i.e., the URL string, HTTP method, and the corresponding data from a request), using an inter-procedural static string analysis (i.e., program analysis capable of extracting strings [22]). In comparison, static analysis on traditional library API calls in a statically-typed language can be extracted simply via an abstract syntax tree.

• •

Because web APIs are commonly used in code written in dynamically typed languages such as JavaScript, we targeted our analysis on JavaScript code. Typically, inter-procedural static whole-program analysis on JavaScript code is more challenging (i.e., less scalable, due difficulties from dynamical typing) than the same analysis on Java code [23, 24, 25, 22]. For the initial implementation, we chose to handle requests written using the jQuery framework due to its popularity – reportedly,  70% of websites use the jQuery framework [26].

IV-C Evaluation and Relevance to Web API Researchers

To evaluate our approach, we applied our approach by checking whether web API requests from over $6000$ JavaScript files on GitHub333https://github.com/ were consistent or inconsistent with publicly available web API specifications provided by the APIs Guru project [17]. Other researchers in web API research may also want to consider using the public web API specifications such as the data from APIs Guru project for the evaluation of approaches like our static analysis.

V IDE Support for Checking Web API Requests

This section demonstrates the practical significance of research we presented in Sections III and IV through a new IDE integration taking advantage of both research efforts.

From a high level, providing static checking comprises two steps: First, we use inter-procedural static analysis [8] discussed in section IV to extract string-based information about the request, including the request URL string, HTTP method, and the corresponding request data. Recall the code in Figure 1 as an example. Focusing on the url variable, we can see that it is composed from two constant strings and the tag variable in the function getPictureForTag. The value of url is then first passed into a field of the settings object, and ultimately flows into jQuery’s Ajax call $.ajax in the sendRequest function. The value of tag is a parameter and could be different in multiple runs. Hence, when we aim to extract the URL used in this request, we denote tag as a symbolic value {tag} using curly braces, indicating that the value is not known statically. Overall, the URL extracted for the shown request is https://api.instagram.com/v1/tags/ {tag}/media/recent.

Second, a checking component determines whether extracted requests conform to any known web API specification, possibly curated as described in section III. To do so, the checking component retrieves one or more specifications from the database that define a host matching the one in the extracted request URL. Multiple specifications may be found as multiple versions of an API can share the same host. The component then in sequence checks whether the protocol, base path, route, and HTTP method match. If any of these matches fail for all of the retrieved specifications, an error is reported. If at least one endpoint (route and HTTP method [7]) was matched across the specifications, the component checks if required query parameters are part of the extracted URL and if payload data requirements are met by extracted payload data. Again, if any of these conditions fail for all matched endpoints, an error is reported. Otherwise, the request is deemed valid. This approach is conservative in that it only reports errors if no match can be found at all.

We implemented a corresponding checking procedure as a prototypical plugin for the Atom code editor [27]. Code checks are performed with some delay upon every user input, given that the edited code contains a web API request. The checking is a relatively expensive operation, which is thus invoked via asynchronous request to be performed by an external service. While this architecture works for an initial prototype, it might need revision due to concerns of sending source code to an external service. Results of the checking procedure are displayed using overlays within the Atom editor, either reporting the error (cf. Figure 2a) or what was successfully checked (cf. Figure 2b).

VI Conclusion

In this paper, we argue for software engineering research addressing the consumption of web APIs – a topic that is of high relevance in practice, but has seen little attention from research so far. We discussed the nature of challenges in this field by means of two concrete examples of our work, and presented new work on how research efforts can be applied to support developers in consuming web APIs without errors.