How do developers use APIs? A case study in concurrency

Stefan Blom, Joseph Kiniry, Marieke Huisman

Research output: Chapter in Book/Report/Conference proceedingConference contributionAcademicpeer-review

6 Citations (Scopus)
80 Downloads (Pure)

Abstract

With the omnipresent usage of APIs in software development, it has become important to analyse how the routines and functionalities of APIs are actually used. This information is in particular useful for API developers, to make decisions about future updates of the API. However, also for developers of static analysis and verification tools this information is highly important, because it indicates where and how to put the most efficient effort in annotating APIs, to make them usable for the static analysis and verification tools. This paper presents an analysis of the usage of the routines and functionalities of the Java concurrency library java.util.concurrent. It discusses the Histogram tool that we developed for this purpose, i.e., to efficiently analyse a large collection of bytecode classes. The Histogram tool is used on a representative benchmark set, the Qualitas Corpus. The paper discusses the results of the analysis of this benchmark set in detail. This covers both an analysis of the important classes and methods used by the current releases of the benchmark collection, as well as an analysis of the time it took for the Java concurrency library to start being used in released software.
Original languageUndefined
Title of host publicationProceedings of the 18th International Conference on Engineering of Complex Computer Systems, ICECCS 2013
Place of PublicationUSA
PublisherIEEE Computer Society
Pages212-221
Number of pages10
ISBN (Print)978-0-7695-5007-7
DOIs
Publication statusPublished - Jul 2013

Publication series

Name
PublisherIEEE Computer Society

Keywords

  • EWI-24441
  • Qualitas Corpus
  • Static Analysis
  • IR-89586
  • API usage
  • METIS-302698
  • java.util.concurrent

Cite this

Blom, S., Kiniry, J., & Huisman, M. (2013). How do developers use APIs? A case study in concurrency. In Proceedings of the 18th International Conference on Engineering of Complex Computer Systems, ICECCS 2013 (pp. 212-221). USA: IEEE Computer Society. https://doi.org/10.1109/ICECCS.2013.39
Blom, Stefan ; Kiniry, Joseph ; Huisman, Marieke. / How do developers use APIs? A case study in concurrency. Proceedings of the 18th International Conference on Engineering of Complex Computer Systems, ICECCS 2013. USA : IEEE Computer Society, 2013. pp. 212-221
@inproceedings{8cb647cb093c4ad489653076826c0650,
title = "How do developers use APIs? A case study in concurrency",
abstract = "With the omnipresent usage of APIs in software development, it has become important to analyse how the routines and functionalities of APIs are actually used. This information is in particular useful for API developers, to make decisions about future updates of the API. However, also for developers of static analysis and verification tools this information is highly important, because it indicates where and how to put the most efficient effort in annotating APIs, to make them usable for the static analysis and verification tools. This paper presents an analysis of the usage of the routines and functionalities of the Java concurrency library java.util.concurrent. It discusses the Histogram tool that we developed for this purpose, i.e., to efficiently analyse a large collection of bytecode classes. The Histogram tool is used on a representative benchmark set, the Qualitas Corpus. The paper discusses the results of the analysis of this benchmark set in detail. This covers both an analysis of the important classes and methods used by the current releases of the benchmark collection, as well as an analysis of the time it took for the Java concurrency library to start being used in released software.",
keywords = "EWI-24441, Qualitas Corpus, Static Analysis, IR-89586, API usage, METIS-302698, java.util.concurrent",
author = "Stefan Blom and Joseph Kiniry and Marieke Huisman",
note = "10.1109/ICECCS.2013.39",
year = "2013",
month = "7",
doi = "10.1109/ICECCS.2013.39",
language = "Undefined",
isbn = "978-0-7695-5007-7",
publisher = "IEEE Computer Society",
pages = "212--221",
booktitle = "Proceedings of the 18th International Conference on Engineering of Complex Computer Systems, ICECCS 2013",
address = "United States",

}

Blom, S, Kiniry, J & Huisman, M 2013, How do developers use APIs? A case study in concurrency. in Proceedings of the 18th International Conference on Engineering of Complex Computer Systems, ICECCS 2013. IEEE Computer Society, USA, pp. 212-221. https://doi.org/10.1109/ICECCS.2013.39

How do developers use APIs? A case study in concurrency. / Blom, Stefan; Kiniry, Joseph; Huisman, Marieke.

Proceedings of the 18th International Conference on Engineering of Complex Computer Systems, ICECCS 2013. USA : IEEE Computer Society, 2013. p. 212-221.

Research output: Chapter in Book/Report/Conference proceedingConference contributionAcademicpeer-review

TY - GEN

T1 - How do developers use APIs? A case study in concurrency

AU - Blom, Stefan

AU - Kiniry, Joseph

AU - Huisman, Marieke

N1 - 10.1109/ICECCS.2013.39

PY - 2013/7

Y1 - 2013/7

N2 - With the omnipresent usage of APIs in software development, it has become important to analyse how the routines and functionalities of APIs are actually used. This information is in particular useful for API developers, to make decisions about future updates of the API. However, also for developers of static analysis and verification tools this information is highly important, because it indicates where and how to put the most efficient effort in annotating APIs, to make them usable for the static analysis and verification tools. This paper presents an analysis of the usage of the routines and functionalities of the Java concurrency library java.util.concurrent. It discusses the Histogram tool that we developed for this purpose, i.e., to efficiently analyse a large collection of bytecode classes. The Histogram tool is used on a representative benchmark set, the Qualitas Corpus. The paper discusses the results of the analysis of this benchmark set in detail. This covers both an analysis of the important classes and methods used by the current releases of the benchmark collection, as well as an analysis of the time it took for the Java concurrency library to start being used in released software.

AB - With the omnipresent usage of APIs in software development, it has become important to analyse how the routines and functionalities of APIs are actually used. This information is in particular useful for API developers, to make decisions about future updates of the API. However, also for developers of static analysis and verification tools this information is highly important, because it indicates where and how to put the most efficient effort in annotating APIs, to make them usable for the static analysis and verification tools. This paper presents an analysis of the usage of the routines and functionalities of the Java concurrency library java.util.concurrent. It discusses the Histogram tool that we developed for this purpose, i.e., to efficiently analyse a large collection of bytecode classes. The Histogram tool is used on a representative benchmark set, the Qualitas Corpus. The paper discusses the results of the analysis of this benchmark set in detail. This covers both an analysis of the important classes and methods used by the current releases of the benchmark collection, as well as an analysis of the time it took for the Java concurrency library to start being used in released software.

KW - EWI-24441

KW - Qualitas Corpus

KW - Static Analysis

KW - IR-89586

KW - API usage

KW - METIS-302698

KW - java.util.concurrent

U2 - 10.1109/ICECCS.2013.39

DO - 10.1109/ICECCS.2013.39

M3 - Conference contribution

SN - 978-0-7695-5007-7

SP - 212

EP - 221

BT - Proceedings of the 18th International Conference on Engineering of Complex Computer Systems, ICECCS 2013

PB - IEEE Computer Society

CY - USA

ER -

Blom S, Kiniry J, Huisman M. How do developers use APIs? A case study in concurrency. In Proceedings of the 18th International Conference on Engineering of Complex Computer Systems, ICECCS 2013. USA: IEEE Computer Society. 2013. p. 212-221 https://doi.org/10.1109/ICECCS.2013.39