Skip to main content
SpringerLink
Log in

How do developers react to API evolution? A large-scale empirical study

  • Published:
Software Quality Journal Aims and scope Submit manuscript

Abstract

Software engineering research now considers that no system is an island, but it is part of an ecosystem involving other systems, developers, and users. When a framework or a library evolves, its clients often must adapt. For example, client developers might need to adapt to functionalities, client systems might need to be adapted to a new API, and client users might need to adapt to a new user interface. The consequences of these changes are yet unclear: what proportion of the ecosystem might be expected to react, how long might it take for a change to diffuse in the ecosystem, do all clients react in the same way? This paper reports an exploratory study aimed at observing API evolution and its impact on a large software ecosystem, Pharo, which has about 3600 distinct systems, and 6 years of evolution. We analyze 118 API changes in the context of method replacement and suggestion, and answer research questions regarding the magnitude, duration, extension, and consistency of such changes in the ecosystem. The results of this study help to characterize the impact of API evolution in large software ecosystems and provide the basis to better understand how such impact can be alleviated.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7
Fig. 8
Fig. 9
Fig. 10
Fig. 11
Fig. 12
Fig. 13
Fig. 14
Fig. 15
Fig. 16

Similar content being viewed by others

Notes

  1. 1 http://www.pharo.org

  2. 2 http://www.moosetechnology.org

  3. 3 See the mailing discussion in: http://goo.gl/Ul3Sha

  4. 4 http://consortium.pharo.org

  5. 5 http://www.seaside.st

  6. 6 http://www.phratch.com

  7. 7 http://scratch.mit.edu

  8. 8 Main and alternative replacements of API changes in the ecosystem are determined by verifying how the ecosystem replaces the old calls. This is done by applying our approach described in Section 2 in the ecosystem itself.

  9. 9 http://forum.world.st/moving-moose-to-pharo-3-0-td4718927.html

  10. 10 Coordination via Question and Answer sites: http://stackoverflow.com/questions/15757529/porting-code-to-pharo-2-0 http://stackoverflow.com/questions/15757529/porting-code-to-pharo-2-0

  11. 11 Coordination via mailing lists: http://goo.gl/50q2yZ, http://goo.gl/k9Fl0K, http://goo.gl/SkMORX

References

  • Bavota, G, Canfora, G, Penta, M D, Oliveto, R, & Panichella, S (2013). The evolution of project inter-dependencies in a software ecosystem: the case of Apache. In International conference on software maintenance.

  • Bavota, G, Linares-Vasquez, M, Bernal-Cardenas, C E, Di Penta, M, Oliveto, R, & Poshyvanyk, D (2015). The impact of api change-and fault-proneness on the user ratings of android apps. IEEE Transactions on Software Engineering, 41 (4).

  • Boulanger, J, & Robillard, M (2006). Managing concern interfaces. In International Conference on Software Maintenance.

  • Brito, G, Hora, A, Valente, M T, & Robbes, R (2016). Do developers deprecate APIs with replacement messages? A large-scale analysis on Java systems. In International conference on software analysis, evolution and reengineering.

  • Businge, J, Serebrenik, A, & van den Brand, MG (2013). Eclipse API usage: the good and the bad. Software Quality Journal.

  • Chow, K, & Notkin, D (1996). Semi-automatic update of applications in response to library changes. In International conference on software maintenance.

  • Cossette, B E, & Walker, R J (2012). Seeking the ground truth: a retroactive study on the evolution and migration of software libraries. In International symposium on the foundations of software engineering.

  • Dagenais, B, & Robillard, MP (2008). Recommending adaptive changes for framework evolution. In International conference on software engineering.

  • Dig, D, & Johnson, R (2005). The role of refactorings in API evolution. In International conference on software maintenance.

  • German, D M, & Adams, B (2013). Hassan AE, The evolution of the R software ecosystem. In European conference on software maintenance and reengineering.

  • Gokhale, A, Ganapathy, V, & Padmanaban, Y (2013). Inferring likely mappings between APIs. In International conference on software engineering.

  • Gonzalez-Barahona, J M, Robles, G, Michlmayr, M, Amor, J J, & German, D M (2009). Macro-level software evolution: a case study of a large software compilation. Empirical Software Engineering, 14(3).

  • Haenni, N, Lungu, M, Schwarz, N, & Nierstrasz, O (2014). A quantitative analysis of developer information needs in software ecosystems. In European conference on software architecture workshops.

  • Henkel, J, & Diwan, A (2005). Catchup!: capturing and replaying refactorings to support API evolution. In: International conference on software engineering.

  • Hora, A, & Valente, M T (2015). apiwave: keeping track of API popularity and migration. In International conference on software maintenance and evolution. http://apiwave.com.

  • Hora, A, Anquetil, N, Ducasse, S, & Allier, S (2012). Domain specific warnings: are they any better? In International conference on software maintenance.

  • Hora, A, Etien, A, Anquetil, N, Ducasse, S, & Valente, M T (2014). APIEvolutionMiner: keeping API evolution under control. In Software evolution week (european conference on software maintenance and working conference on reverse engineering.

  • Hora, A, Anquetil, N, Etien, A, Ducasse, S, & Valente, M T (2015a). Automatic detection of system-specific conventions unknown to developers. Journal of Systems and Software, 109.

  • Hora, A, Robbes, R, Anquetil, N, Etien, A, Ducasse, S, & Valente, MT (2015b). How do developers react to API evolution? The Pharo ecosystem case. In International conference on software maintenance and evolution.

  • Hora, A, Valente, M T, Robbes, R, & Anquetil, N (2016). When should internal interfaces be promoted to public? In International symposium on the foundations of software engineering.

  • Jansen, S, Brinkkemper, S, & Cusumano, M (2013). Software ecosystems: analyzing and managing business networks in the software industry. Edward Elgar Pub.

  • Jergensen, C, Sarma, A, & Wagstrom, P (2011). The onion patch: migration in open source ecosystems. In European conference on foundations of software engineering.

  • Kim, M, & Notkin, D (2009). Discovering and representing systematic code changes. In International conference on software engineering.

  • Kim, M, Notkin, D, & Grossman, D (2007). Automatic inference of structural changes for matching across program versions. In International conference on software engineering.

  • Linares-Vásquez, M, Bavota, G, Di Penta, M, Oliveto, R, & Poshyvanyk, D (2014). How do API changes trigger stack overflow discussions? A study on the android SDK. In International conference on program comprehension.

  • Lungu, M (2009). Reverse engineering software ecosystems. PhD thesis, University of Lugano, Switzerland.

  • Lungu, M, Lanza, M, Gîrba, T, & Robbes, R (2010a). The small project observatory: visualizing software ecosystems. Science of Computer Programming, 75(4).

  • Lungu, M, Robbes, R, & Lanza, M (2010b). Recovering inter-project dependencies in software ecosystems. In International conference on automated software engineering.

  • McDonnell, T, Ray, B, & Kim, M (2013). An empirical study of API stability and adoption in the android ecosystem. In International conference on software maintenance.

  • Meng, S, Wang, X, Zhang, L, & Mei, H (2012). A history-based matching approach to identification of framework evolution. In International conference on software engineering.

  • Mens, T, Claes, M, Grosjean, P, & Serebrenik, A (2014). Studying evolving software ecosystems based on ecological models. In Mens, T, Serebrenik, A, & Cleve, A (Eds.) Evolving software systems. Berlin Heidelberg: Springer.

  • Messerschmitt, D G, & Szyperski, C (2005). Software ecosystem: understanding an indispensable technology and industry. MIT Press Books, 1.

  • Nguyen, H A, Nguyen, T T, Wilson, G Jr, Nguyen, A T, Kim, M, & Nguyen, TN (2010). A graph-based approach to API usage adaptation. In International conference on object oriented programming systems languages and applications.

  • Robbes, R, Lungu, M, & Röthlisberger, D (2012). How do developers react to API deprecation? The case of a smalltalk ecosystem. In International symposium on the foundations of software engineering.

  • Schäfer, T, Jonas, J, & Mezini, M (2008). Mining framework usage changes from instantiation code. In International conference on software engineering.

  • Schwarz, N, Lungu, M, & Robbes, R (2012). On how often code is cloned across repositories. In International conference on software engineering.

  • Wu, W, Gueheneuc, Y G, Antoniol, G, & Kim, M (2010). Aura: a hybrid approach to identify framework evolution. In International conference on software engineering.

  • Wu, W, Khomh, F, Adams, B, Guéhéneuc, YG, & Antoniol, G (2016). An exploratory study of API changes and usages based on apache and eclipse ecosystems. Empirical Software Engineering.

  • Zaki, M, & Meira, W Jr (2012). Fundamentals of data mining algorithms.

  • Zhong, H, Thummalapenta, S, Xie, T, Zhang, L, & Wang, Q (2010). Mining API mapping for language migration. In International conference on software engineering.

Download references

Acknowledgment

This research was supported by CNPq, FAPEMIG, Fundect-MS (007/2015), and ANR (ANR-2010-BLAN- 0219-01).

Author information

Authors and Affiliations

  1. FACOM, Federal University of Mato Grosso do Sul, Campo Grande, Brazil

    André Hora

  2. ASERG Group, Department of Computer Science (DCC), Federal University of Minas Gerais, Belo Horizonte, Brazil

    Marco Tulio Valente

  3. PLEIAD Lab, Department of Computer Science (DCC), University of Chile, Santiago, Chile

    Romain Robbes

  4. RMoD Team, Inria, Lille, France

    Nicolas Anquetil, Anne Etien & Stéphane Ducasse

Authors
  1. André Hora
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Romain Robbes
    View author publications

    You can also search for this author in PubMed Google Scholar

  3. Marco Tulio Valente
    View author publications

    You can also search for this author in PubMed Google Scholar

  4. Nicolas Anquetil
    View author publications

    You can also search for this author in PubMed Google Scholar

  5. Anne Etien
    View author publications

    You can also search for this author in PubMed Google Scholar

  6. Stéphane Ducasse
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to André Hora.

Rights and permissions

Reprints and permissions

About this article

Check for updates. Verify currency and authenticity via CrossMark

Cite this article

Hora, A., Robbes, R., Valente, M.T. et al. How do developers react to API evolution? A large-scale empirical study. Software Qual J 26, 161–191 (2018). https://doi.org/10.1007/s11219-016-9344-4

Download citation

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s11219-016-9344-4

Keywords

Search

Navigation