skip to main content
research-article
Open access

Understanding Software-2.0: A Study of Machine Learning Library Usage and Evolution

Published: 23 July 2021 Publication History

Abstract

Enabled by a rich ecosystem of Machine Learning (ML) libraries, programming using learned models, i.e., Software-2.0, has gained substantial adoption. However, we do not know what challenges developers encounter when they use ML libraries. With this knowledge gap, researchers miss opportunities to contribute to new research directions, tool builders do not invest resources where automation is most needed, library designers cannot make informed decisions when releasing ML library versions, and developers fail to use common practices when using ML libraries.
We present the first large-scale quantitative and qualitative empirical study to shed light on how developers in Software-2.0 use ML libraries, and how this evolution affects their code. Particularly, using static analysis we perform a longitudinal study of 3,340 top-rated open-source projects with 46,110 contributors. To further understand the challenges of ML library evolution, we survey 109 developers who introduce and evolve ML libraries. Using this rich dataset we reveal several novel findings.
Among others, we found an increasing trend of using ML libraries: The ratio of new Python projects that use ML libraries increased from 2% in 2013 to 50% in 2018. We identify several usage patterns including the following: (i) 36% of the projects use multiple ML libraries to implement various stages of the ML workflows, (ii) developers update ML libraries more often than the traditional libraries, (iii) strict upgrades are the most popular for ML libraries among other update kinds, (iv) ML library updates often result in cascading library updates, and (v) ML libraries are often downgraded (22.04% of cases). We also observed unique challenges when evolving and maintaining Software-2.0 such as (i) binary incompatibility of trained ML models and (ii) benchmarking ML models. Finally, we present actionable implications of our findings for researchers, tool builders, developers, educators, library vendors, and hardware vendors.

References

[1]
Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek G. Murray, Benoit Steiner, Paul Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. 2016. TensorFlow: A system for large-scale machine learning. In Proceedings of the 12th USENIX Symposium on Operating Systems Design and Implementation (OSDI’16). USENIX Association, 265–283.
[2]
Edward Aftandilian, Raluca Sauciuc, Siddharth Priya, and Sundaresan Krishnan. 2012. Building useful program analysis tools using an extensible Java compiler. In Proceedings of the 2012 IEEE 12th International Working Conference on Source Code Analysis and Manipulation (SCAM’12). IEEE Computer Society, Los Alamitos, CA, 14–23. https://doi.org/10.1109/SCAM.2012.28
[3]
Emad Aghajani, Csaba Nagy, Olga Lucero Vega-Márquez, Mario Linares-Vásquez, Laura Moreno, Gabriele Bavota, and Michele Lanza. 2019. Software documentation issues unveiled. In Proceedings of the 41st International Conference on Software Engineering (ICSE’19). IEEE Press, 1199–1210. https://doi.org/10.1109/ICSE.2019.00122
[4]
Rami Al-Rfou, Guillaume Alain, Amjad Almahairi, Christof Angermueller, Dzmitry Bahdanau, Nicolas Ballas, Frédéric Bastien, Justin Bayer, Anatoly Belikov, Alexander Belopolsky, et al. 2016. Theano: A Python framework for fast computation of mathematical expressions.
[5]
Hussein Alrubaye, Deema AlShoaibi, Mohamed Wiem Mkaouer, and Ali Ouni. 2019. How does API migration impact software quality and comprehension? An empirical study. arxiv:cs.SE/1907.07724. Retrieved from https://arxiv.org/abs/1907.07724.
[6]
Theodoros Amanatidis and Alexander Chatzigeorgiou. 2016. Studying the evolution of PHP Web applications. Inf. Softw. Technol. 72, C (Apr. 2016), 48–67. https://doi.org/10.1016/j.infsof.2015.11.009
[7]
AMD. 2020. Deep Learning Solutions. Retrieved February 1, 2020 from https://www.amd.com/en/graphics/servers-radeon-instinct-deep-learning.
[8]
Saleema Amershi, Andrew Begel, Christian Bird, Robert DeLine, Harald Gall, Ece Kamar, Nachiappan Nagappan, Besmira Nushi, and Thomas Zimmermann. 2019. Software engineering for machine learning: A case study. In Proceedings of the 41st International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP’19). IEEE Press, Los Alamitos, CA, 291–300. https://doi.org/10.1109/ICSE-SEIP.2019.00042
[9]
Apache. 2019. Frequent Pattern Mining. Retrieved January 7, 2020 from https://spark.apache.org/docs/latest/ml-frequent-pattern-mining.html#fp-growth.
[10]
Apple. 2020. Machine Learning. Retrieved February 1, 2020 from https://developer.apple.com/machine-learning/.
[11]
Cyrille Artho, Kuniyasu Suzaki, Roberto Di Cosmo, Ralf Treinen, and Stefano Zacchiroli. 2012. Why do software packages conflict? In Proceedings of the 9th IEEE Working Conference on Mining Software Repositories (MSR’12). IEEE Press, 141–150. https://doi.org/10.1109/MSR.2012.6224274
[12]
Muhammad Asaduzzaman, Chanchal K. Roy, Samiul Monir, and Kevin A. Schneider. 2015. Exploring API method parameter recommendations. In Proceedings of the 2015 IEEE International Conference on Software Maintenance and Evolution (ICSME’15). IEEE Computer Society, Los Alamitos, CA, 271–280. https://doi.org/10.1109/ICSM.2015.7332473
[13]
Shams Azad, Peter C. Rigby, and Latifa Guerrouj. 2017. Generating API call rules from version history and stack overflow posts. ACM Trans. Softw. Eng. Methodol. 25, 4, Article 29 (Jan. 2017), 22 pages. https://doi.org/10.1145/2990497
[14]
Abdul Ali Bangash, Hareem Sahar, Shaiful Chowdhury, Alexander William Wong, Abram Hindle, and Karim Ali. 2019. What do developers know about machine learning: A study of ML discussions on stackoverflow. In Proceedings of the 16th International Conference on Mining Software Repositories (MSR’19). IEEE Press, Los Alamitos, CA, 260–264. https://doi.org/10.1109/MSR.2019.00052
[15]
Gabriele Bavota, Gerardo Canfora, Massimiliano Di Penta, Rocco Oliveto, and Sebastiano Panichella. 2015. How the apache community upgrades dependencies: An evolutionary study. Emp. Softw. Eng. 20, 5 (Oct. 2015), 1275–1317. https://doi.org/10.1007/s10664-014-9325-9
[16]
Gabriele Bavota, Gerardo Canfora, Massimiliano Di Penta, Rocco Oliveto, and Sebastiano Panichella. 2013. The evolution of project inter-dependencies in a software ecosystem: The case of apache. In Proceedings of the 2013 IEEE International Conference on Software Maintenance (ICSM’13). IEEE Computer Society, Los Alamitos, CA, 280–289. https://doi.org/10.1109/ICSM.2013.39
[17]
James Bergstra, Dan Yamins, and David D. Cox. 2013. Hyperopt: A Python Library for Optimizing the Hyperparameters of Machine Learning Algorithms. Citeseer.
[18]
Hudson Borges, Andre Hora, and Marco Tulio Valente. 2016. Understanding the factors that impact the popularity of GitHub repositories. In Proceedings of the 2016 IEEE International Conference on Software Maintenance and Evolution (ICSME’16). IEEE, 334–344. https://doi.org/10.1109/ICSME.2016.31
[19]
Hudson Borges and Marco Tulio Valente. 2018. What’s in a GitHub star? Understanding repository starring practices in a social coding platform. J. Syst. Softw. 146 (2018), 112–129. https://doi.org/10.1016/j.jss.2018.09.016
[20]
Houssem Ben Braiek and Foutse Khomh. 2020. On testing machine learning programs. J. Syst. Softw. 164 (2020), 110542. https://doi.org/10.1016/j.jss.2020.110542
[21]
Houssem Ben Braiek, Foutse Khomh, and Bram Adams. 2018. The open-closed principle of modern machine learning frameworks. In Proceedings of the 15th International Conference on Mining Software Repositories (MSR’18). Association for Computing Machinery, New York, NY, 353–363. https://doi.org/10.1145/3196398.3196445
[22]
Virginia Braun and Victoria Clarke. 2006. Using thematic analysis in psychology. Qualitative research in psychology. Qual. Res. Psychol. 3, 2 (2006), 77–101.
[23]
Caius Brindescu, Mihai Codoban, Sergii Shmarkatiuk, and Danny Dig. 2014. How do centralized and distributed version control systems impact software changes? In Proceedings of the 36th International Conference on Software Engineering (ICSE’14). Association for Computing Machinery, New York, NY, 322–333. https://doi.org/10.1145/2568225.2568322
[24]
Haipeng Cai. 2020. Assessing and improving malware detection sustainability through App evolution studies. ACM Trans. Softw. Eng. Methodol. 29, 2, Article 8 (Mar. 2020), 28 pages. https://doi.org/10.1145/3371924
[25]
John L Campbell, Charles Quincy, Jordan Osserman, and Ove K Pedersen. 2013. Coding in-depth semistructured interviews: Problems of unitization and intercoder reliability and agreement. Sociol. Methods Res. 42, 3 (2013), 294–320. https://doi.org/10.1177/0049124113500475
[26]
Hongming Chen, Ola Engkvist, Yinhai Wang, Marcus Olivecrona, and Thomas Blaschke. 2018. The rise of deep learning in drug discovery. Drug Discov. Today 23, 6 (2018), 1241–1250. https://doi.org/10.1016/j.drudis.2018.01.039
[27]
François Chollet et al. 2018. Keras: The python deep learning library. Astrophysics Source Code Library (2018).
[28]
Kingsum Chow and David Notkin. 1996. Semi-automatic update of applications in response to library changes. In Proceedings of the 1996 International Conference on Software Maintenance (ICSM’96). IEEE Computer Society, Los Alamitos, CA, 359.
[29]
Ronan Collobert, Samy Bengio, and Johnny Mariéthoz. 2002. Torch: A Modular Machine Learning Software Library. Technical Report. Idiap.
[30]
Bradley E. Cossette and Robert J. Walker. 2012. Seeking the ground truth: A retroactive study on the evolution and migration of software libraries. In Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering (FSE’12). Association for Computing Machinery, New York, NY. https://doi.org/10.1145/2393596.2393661
[31]
Daniela S Cruzes and Tore Dybå. 2011. Research synthesis in software engineering: A tertiary study. Inf. Softw. Technol. 53, 5 (2011), 440–455. https://doi.org/10.1016/j.infsof.2011.01.004
[32]
Barthelemy Dagenais and Martin P. Robillard. 2009. SemDiff: Analysis and recommendation support for API evolution. In Proceedings of the 31st International Conference on Software Engineering (ICSE’09). IEEE Computer Society, Los Alamitors, CA, 599–602. https://doi.org/10.1109/ICSE.2009.5070565
[33]
Sato Danilo, Wider Arif, and Windheuser Christoph. 2020. Continuous Delivery for Machine Learning. Retrieved March 26, 2020 from https://martinfowler.com/articles/cd4ml.html.
[34]
Databricks. 2020. Open Source Platform for Managing the End-to-End Machine Learning Lifecycle. Retrieved March 26, 2020 from https://www.mlflow.org/docs/latest/projects.html.
[35]
Alexandre Decan, Tom Mens, and Philippe Grosjean. 2019. An empirical comparison of dependency network evolution in seven software packaging ecosystems. Emp. Softw. Eng. 24, 1 (Feb. 2019), 381–416. https://doi.org/10.1007/s10664-017-9589-y
[36]
Dependabot. 2019. Dependabot. Retrieved June 13, 2019 from https://dependabot.com.
[37]
Erik Derr, Sven Bugiel, Sascha Fahl, Yasemin Acar, and Michael Backes. 2017. Keep me updated: An empirical study of third-party library updatability on Android. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security (CCS’17). Association for Computing Machinery, New York, NY, 2187–2200. https://doi.org/10.1145/3133956.3134059
[38]
J. Dietrich, K. Jezek, and P. Brada. 2014. Broken promises: An empirical study into evolution problems in Java programs caused by library upgrades. In Proceedings of the IEEE Conference on Software Maintenance, Reengineering, and Reverse Engineering (CSMR-WCRE’14). IEEE Computer Society, Los Alamitos, CA, 64–73. https://doi.org/10.1109/CSMR-WCRE.2014.6747226
[39]
Danny Dig and Ralph Johnson. 2005. The role of refactorings in API evolution. In Proceedings of the 21st IEEE International Conference on Software Maintenance (ICSM’05). IEEE Computer Society, Los Alamitos, CA, 389–398. https://doi.org/10.1109/ICSM.2005.90
[40]
Danny Dig and Ralph Johnson. 2006. How do APIs evolve? A story of refactoring: Research articles. J. Softw. Maint. Evol. 18, 2 (Mar. 2006), 83–107. https://doi.org/10.1002/smr.328
[41]
Julian Dolby, Avraham Shinnar, Allison Allain, and Jenna Reinen. 2018. Ariadne: Analysis for machine learning programs. In Proceedings of the 2nd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages (MAPL’18). ACM, New York, NY, 1–10. https://doi.org/10.1145/3211346.3211349
[42]
Georg Dotzler, Marius Kamp, Patrick Kreutzer, and Michael Philippsen. 2017. More accurate recommendations for method-level changes. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE’17). Association for Computing Machinery, New York, NY, 798–808.
[43]
Robert Dyer, Hridesh Rajan, Hoan Anh Nguyen, and Tien N. Nguyen. 2014. Mining billions of AST nodes to study actual and potential usage of Java language features. In Proceedings of the 36th International Conference on Software Engineering (ICSE’14). Association for Computing Machinery, New York, NY, 779–790.
[44]
Andrea Renika D’Souza, Di Yang, and Cristina V. Lopes. 2016. Collective intelligence for smarter API recommendations in Python. In Proceedings of the 2016 IEEE 16th International Working Conference on Source Code Analysis and Manipulation (SCAM’16). IEEE Press, Los Alamitos, CA, 51–60. https://doi.org/10.1109/SCAM.2016.22
[45]
Steve Easterbrook, Janice Singer, Margaret-Anne Storey, and Daniela Damian. 2008. Selecting empirical methods for software engineering research. In Guide to Advanced Empirical Software Engineering. Springer, 285–311.
[46]
Mattia Fazzini, Qi Xin, and Alessandro Orso. 2019. Automated API-usage update for Android Apps. In Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA’19). Association for Computing Machinery, New York, NY, 204–215.
[47]
Darius Foo, Hendy Chua, Jason Yeo, Ming Yi Ang, and Asankhaya Sharma. 2018. Efficient static checking of library updates. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE’18). Association for Computing Machinery, New York, NY, 791–796.
[48]
Apache Software Foundation. 2019. Introduction to the POM. Retrieved December 26, 2019 from https://maven.apache.org/guides/introduction/introduction-to-the-pom.html.
[49]
Python Foundation. 2019. Requirements File Format. Retrieved June 13, 2019 from https://pip.pypa.io/en/stable/reference/pip_install/.
[50]
Python Software Foundation. 2019. Python Type Hints. Retrieved October 13, 2019 from https://docs.python.org/3/library/typing.html.
[51]
Python Software Foundation. 2019. Version Identification and Dependency Specification. Retrieved August 23, 2019 from https://www.python.org/dev/peps/pep-0440/.
[52]
Martin Fowler. 2018. Refactoring: Improving the Design of Existing Code. Addison-Wesley Professional.
[53]
Martin Fowler. 2019. Continuous Delivery for Machine Learning. Retrieved February 2, 2020 from https://martinfowler.com/articles/cd4ml.html.
[54]
Daniel M. German, Bram Adams, and Ahmed E. Hassan. 2013. The evolution of the R software ecosystem. In Proceedings of the 2013 17th European Conference on Software Maintenance and Reengineering (CSMR’13). IEEE Computer Society, Los Alamitos, CA, 243–252.
[55]
Jiawei Han, Jian Pei, and Yiwen Yin. 2000. Mining frequent patterns without candidate generation. In Proceedings of the 2000 ACM SIGMOD International Conference on Management of Data (SIGMOD’00). Association for Computing Machinery, New York, NY, 1–12.
[56]
Junxiao Han, Emad Shihab, Zhiyuan Wan, Shuiguang Deng, and Xin Xia. 2020. What do programmers discuss about deep learning frameworks. Emp. Softw. Eng. 25, 4 (2020), 2694–2747. https://doi.org/10.1007/s10664-020-09819-6
[57]
Vincent J. Hellendoorn, Christian Bird, Earl T. Barr, and Miltiadis Allamanis. 2018. Deep learning type inference. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE’18). Association for Computing Machinery, New York, NY, 152–162.
[58]
Johannes Henkel and Amer Diwan. 2005. CatchUp! Capturing and replaying refactorings to support API evolution. In Proceedings of the 27th International Conference on Software Engineering (ICSE’05). Association for Computing Machinery, New York, NY, 274–283.
[59]
Rosco Hill and Joe Rideout. 2004. Automatic method completion. In Proceedings of the 19th IEEE International Conference on Automated Software Engineering (ASE’04). IEEE Computer Society, Los Alamitos, CA, 228–235.
[60]
Michael Hilton, Timothy Tunnell, Kai Huang, Darko Marinov, and Danny Dig. 2016. Usage, costs, and benefits of continuous integration in open-source projects. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering (ASE’16). Association for Computing Machinery, New York, NY, 426–437. https://doi.org/10.1145/2970276.2970358
[61]
Andre Hora, Romain Robbes, Nicolas Anquetil, Anne Etien, Stephane Ducasse, and Marco Tulio Valente. 2015. How do developers react to API evolution? The pharo ecosystem case. In Proceedings of the 2015 IEEE International Conference on Software Maintenance and Evolution (ICSME’15). IEEE Computer Society, Los Alamitos, CA, 251–260.
[62]
Nargiz Humbatova, Gunel Jahangirova, Gabriele Bavota, Vincenzo Riccio, Andrea Stocco, and Paolo Tonella. 2020. Taxonomy of real faults in deep learning systems. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering (ICSE’20). Association for Computing Machinery, 1110–1121.
[63]
IBM. 2020. Get started with PyTorch. Retrieved February 1, 2020 https://developer.ibm.com/articles/cc-get-started-pytorch/.
[64]
Pachyderm Inc. 2019. Pachyderm. Retrieved February 2, 2020 from https://www.pachyderm.com/platform/#community.
[65]
Intel. 2019. Intel Caffe. Retrieved November 19, 2019 from https://github.com/intel/caffe.
[66]
Intel. 2019. Intel Optimization for TensorFlow*. Retrieved January 3, 2020 from https://software.intel.com/en-us/frameworks/tensorflow.
[67]
Intel. 2019. Intel TensorFlow. Retrieved November 19, 2019 from https://software.intel.com/en-us/frameworks/tensorflow.
[68]
Intel. 2019. Intel Theano. Retrieved November 19, 2019 from https://github.com/intel/Theano.
[69]
Md Johirul Islam, Giang Nguyen, Rangeet Pan, and Hridesh Rajan. 2019. A comprehensive study on deep learning bug characteristics. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE’19). Association for Computing Machinery, New York, NY, 510–520.
[70]
Md Johirul Islam, Rangeet Pan, Giang Nguyen, and Hridesh Rajan. 2020. Repairing deep neural networks: Fix patterns and challenges. In Proceedings of the 42nd International Conference on Software Engineering (ICSE’20). Association for Computing Machinery, New York, NY, USA, 11.
[71]
JEDI. 2019. Jedi—An Awesome Autocompletion/static Analysis Library for Python. Retrieved August 23, 2019 from https://jedi.readthedocs.io/en/latest/.
[72]
Jetbrains. 2019. Managing Dependencies. Retrieved June 13, 2019 from https://www.jetbrains.com/help/pycharm/managing-dependencies.html.
[73]
Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. 2014. Caffe: Convolutional architecture for fast feature embedding. In Proceedings of the 22nd ACM International Conference on Multimedia. ACM, 675–678.
[74]
Jing Jiang, David Lo, Jiahuan He, Xin Xia, Pavneet Singh Kochhar, and Li Zhang. 2017. Why and how developers fork what from whom in GitHub. Emp. Softw. Eng. 22, 1 (01 Feb. 2017), 547–578.
[75]
Suhas Kabinna, Cor-Paul Bezemer, Weiyi Shang, and Ahmed E. Hassan. 2016. Logging library migrations: A case study for the Apache software foundation projects. In Proceedings of the 13th International Conference on Mining Software Repositories (MSR’16). Association for Computing Machinery, New York, NY, 154–164.
[76]
Huzefa Kagdi, Shehnaaz Yusuf, and Jonathan I. Maletic. 2006. Mining sequences of changed-files from version histories. In Proceedings of the 2006 International Workshop on Mining Software Repositories (MSR’06). Association for Computing Machinery, New York, NY, 47–53.
[77]
Eirini Kalliamvakou, Daniela Damian, Kelly Blincoe, Leif Singer, and Daniel M. German. 2015. Open source-style collaborative development practices in commercial projects using GitHub. In Proceedings of the 37th International Conference on Software Engineering, Volume 1 (ICSE’15). IEEE Press, 574–585.
[78]
Eirini Kalliamvakou, Georgios Gousios, Kelly Blincoe, Leif Singer, Daniel M. German, and Daniela Damian. 2016. An in-depth study of the promises and perils of mining GitHub. Emp. Softw. Eng. 21, 5 (Oct. 2016), 2035–2071.
[79]
Ritu Kapur and Balwinder Sodhi. 2020. A defect estimator for source code: Linking defect reports with programming constructs usage metrics. ACM Trans. Softw. Eng. Methodol. 29, 2, Article 12 (April 2020), 35 pages.
[80]
Andrej Karpathy. 2017. Software 2.0. Retrieved May 5, 2020 from https://medium.com/@karpathy/software-2-0-a64152b37c35.
[81]
Ameya Ketkar, Ali Mesbah, Davood Mazinanian, Danny Dig, and Edward Aftandilian. 2019. Type migration in ultra-large-scale codebases. In Proceedings of the 41st International Conference on Software Engineering (ICSE’19). IEEE Press, 1142–1153. https://doi.org/10.1109/ICSE.2019.00117
[82]
Riivo Kikas, Georgios Gousios, Marlon Dumas, and Dietmar Pfahl. 2017. Structure and evolution of package dependency networks. In Proceedings of the 14th International Conference on Mining Software Repositories (MSR’17). IEEE Press, 102–112. https://doi.org/10.1109/MSR.2017.55
[83]
Miryung Kim, Dongxiang Cai, and Sunghun Kim. 2011. An empirical investigation into the role of API-level refactorings during software evolution. In Proceedings of the 33rd International Conference on Software Engineering (ICSE’11). Association for Computing Machinery, New York, NY, 151–160. https://doi.org/10.1145/1985793.1985815
[84]
Raula Gaikovina Kula, Daniel M German, Takashi Ishio, and Katsuro Inoue. 2015. Trusting a library: A study of the latency to adopt the latest maven release. In Proceedings of the 2015 IEEE 22nd International Conference on Software Analysis, Evolution, and Reengineering (SANER’15). IEEE, 520–524. https://doi.org/10.1109/SANER.2015.7081869
[85]
Raula Gaikovina Kula, Daniel M. German, Ali Ouni, Takashi Ishio, and Katsuro Inoue. 2018. Do developers update their library dependencies?Emp. Softw. Eng. 23, 1 (2018), 384–417. https://doi.org/10.1007/s10664-017-9521-5
[86]
Jun Li, Chenglong Wang, Yingfei Xiong, and Zhenjiang Hu. 2015. SWIN: Towards type-safe Java program adaptation between APIs. In Proceedings of the 2015 Workshop on Partial Evaluation and Program Manipulation (PEPM’15). Association for Computing Machinery, New York, NY, 91–102. https://doi.org/10.1145/2678015.2682534
[87]
Yangguang Li, Zhen Ming (Jack) Jiang, Heng Li, Ahmed E. Hassan, Cheng He, Ruirui Huang, Zhengda Zeng, Mian Wang, and Pinan Chen. 2020. Predicting node failures in an ultra-large-scale cloud computing platform: An AIOps solution. ACM Trans. Softw. Eng. Methodol. 29, 2, Article 13 (Apr. 2020), 24 pages. https://doi.org/10.1145/3385187
[88]
Jimmy Lin and Alek Kolcz. 2012. Large-scale machine learning at Twitter. In Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD’12). ACM, New York, NY, 793–804. https://doi.org/10.1145/2213836.2213958
[89]
Benjamin Livshits and Thomas Zimmermann. 2005. DynaMine: Finding common error patterns by mining software revision histories. SIGSOFT Softw. Eng. Notes 30, 5 (Sep. 2005), 296–305. https://doi.org/10.1145/1095430.1081754
[90]
Siqi Ma, Ferdian Thung, David Lo, Cong Sun, and Robert H. Deng. 2017. Vurle: Automatic vulnerability detection and repair by learning from examples. In Proceedings of the European Symposium on Research in Computer Security. Springer, 229–246. 10.1007/978-3-319-66399-9_13
[91]
Malinda. 2020. Study of Machine Learning Library Usage. Retrieved January 14, 2020 from https://serene-beach-16261.herokuapp.com.
[92]
Brian A. Malloy and James F. Power. 2017. Quantifying the transition from Python 2 to 3: An empirical study of Python applications. In Proceedings of the 2017 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM’17). IEEE, 314–323. https://doi.org/10.1109/ESEM.2017.45
[93]
Davood Mazinanian, Ameya Ketkar, Nikolaos Tsantalis, and Danny Dig. 2017. Understanding the use of lambda expressions in Java. In Proceedings of the ACM Object-oriented Programming, Systems, Languages, and Systems (OOPSLA’17).https://doi.org/10.1145/3133909
[94]
Tyler McDonnell, Baishakhi Ray, and Miryung Kim. 2013. An empirical study of API stability and adoption in the Android ecosystem. In Proceedings of the 2013 IEEE International Conference on Software Maintenance (ICSM’13). IEEE Computer Society, Los Alamitos, CA, 70–79. https://doi.org/10.1109/ICSM.2013.18
[95]
Andrea Mcintosh, Safwat Hassan, and Abram Hindle. 2019. What can Android mobile App developers do about the energy consumption of machine learning?Emp. Softw. Eng. 24, 2 (Apr. 2019), 562–601. https://doi.org/10.1007/s10664-018-9629-2
[96]
Erik Meijer. 2018. Behind every great deep learning framework is an even greater programming languages concept (keynote). In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE’18). Association for Computing Machinery, New York, NY, 1. https://doi.org/10.1145/3236024.3280855
[97]
Na Meng, Miryung Kim, and Kathryn S. McKinley. 2013. LASE: Locating and applying systematic edits by learning from examples. In Proceedings of the 2013 International Conference on Software Engineering (ICSE’13). IEEE Press, 502–511.
[98]
Laura Moreno, Gabriele Bavota, Massimiliano Di Penta, Rocco Oliveto, Andrian Marcus, and Gerardo Canfora. 2016. ARENA: An approach for the automated generation of release notes. IEEE Trans. Softw. Eng. 43, 2 (2016), 106–127. https://doi.org/10.1109/TSE.2016.2591536
[99]
Andreas C Müller, Sarah Guido, et al. 2016. Introduction to Machine Learning with Python: A Guide for Data Scientists. O’Reilly Media, Inc.
[100]
Mypy. 2019. mypy. Retrieved August 23, 2019 from http://mypy-lang.org/.
[101]
Meiyappan Nagappan, Thomas Zimmermann, and Christian Bird. 2013. Diversity in software engineering research. In Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering (ESEC/FSE’13). Association for Computing Machinery, New York, NY, 466–476. https://doi.org/10.1145/2491411.2491415
[102]
A. B. Nassif, I. Shahin, I. Attili, M. Azzeh, and K. Shaalan. 2019. Speech recognition using deep neural networks: A systematic review. IEEE Access 7 (2019), 19143–19165. https://doi.org/10.1109/ACCESS.2019.2896880
[103]
Anh Tuan Nguyen, Hoan Anh Nguyen, Tung Thanh Nguyen, and Tien N. Nguyen. 2012. GraPacc: A graph-based pattern-oriented, context-sensitive code completion tool. In Proceedings of the 34th International Conference on Software Engineering (ICSE’12). IEEE Press, 1407–1410.
[104]
Anh Tuan Nguyen, Tung Thanh Nguyen, Hoan Anh Nguyen, Ahmed Tamrawi, Hung Viet Nguyen, Jafar Al-Kofahi, and Tien N. Nguyen. 2012. Graph-based pattern-oriented, context-sensitive source code completion. In Proceedings of the 34th International Conference on Software Engineering (ICSE’12). IEEE Press, 69–79. https://doi.org/10.1109/ICSE.2012.6227205
[105]
Thanh H. D. Nguyen, Bram Adams, and Ahmed E. Hassan. 2010. Studying the impact of dependency network measures on software quality. In Proceedings of the 2010 IEEE International Conference on Software Maintenance (ICSM’10). IEEE Computer Society, Los Alamitos, CA, 1–10. https://doi.org/10.1109/ICSM.2010.5609560
[106]
Semih Okur and Danny Dig. 2012. How do developers use parallel libraries? In Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering (FSE’12). Association for Computing Machinery, New York, NY. https://doi.org/10.1145/2393596.2393660
[107]
D. L. Parnas. 1972. On the criteria to be used in decomposing systems into modules. Commun. ACM 15, 12 (Dec. 1972), 1053–1058. https://doi.org/10.1145/361598.361623
[108]
Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, et al. 2011. Scikit-learn: Machine learning in Python. J. Mach. Learn. Res. 12 (Oct. 2011), 2825–2830.
[109]
Kexin Pei, Yinzhi Cao, Junfeng Yang, and Suman Jana. 2017. DeepXplore: Automated whitebox testing of deep learning systems. In Proceedings of the 26th Symposium on Operating Systems Principles (SOSP’17). Association for Computing Machinery, New York, NY, 1–18. https://doi.org/10.1145/3132747.3132785
[110]
PIP. 2019. Requirements. Retrieved August 23, 2019 from https://pip.readthedocs.io/en/1.1/requirements.html.
[111]
Python. 2019. PEP Purpose and Guidelines. Retrieved June 13, 2019 from https://www.python.org/dev/peps/pep-0001/.
[112]
Python. 2019. PIP User Guide. Retrieved August 23, 2019 from https://pip.pypa.io/en/stable/user_guide/.
[113]
Realpython. 2019. What Is Pip. Retrieved August 23, 2019 from https://realpython.com/what-is-pip/.
[114]
Xiaoxia Ren, Fenil Shah, Frank Tip, Barbara G. Ryder, and Ophelia Chesley. 2004. Chianti: A tool for change impact analysis of Java programs. In Proceedings of the 19th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA’04). Association for Computing Machinery, New York, NY, 432–448. https://doi.org/10.1145/1028976.1029012
[115]
R. Robbes and M. Lanza. 2008. How program history can improve code completion. In Proceedings of the 2008 23rd IEEE/ACM International Conference on Automated Software Engineering (ASE’08). IEEE Computer Society, Los Alamitos, CA, 317–326. https://doi.org/10.1109/ASE.2008.42
[116]
Romain Robbes, Mircea Lungu, and David Röthlisberger. 2012. How do developers react to API deprecation? The case of a smalltalk ecosystem. In Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering (FSE’12). ACM, New York, NY, Article 56, 11 pages. https://doi.org/10.1145/2393596.2393662
[117]
Martin P. Robillard and Robert Deline. 2011. A field study of API learning obstacles. Emp. Softw. Eng. 16, 6 (Dec. 2011), 703–732. https://doi.org/10.1007/s10664-010-9150-8
[118]
Peter Rousseeuw. 1987. Silhouettes: A graphical aid to the interpretation and validation of cluster analysis. J. Comput. Appl. Math. 20, 1 (Nov. 1987), 53–65. https://doi.org/10.1016/0377-0427(87)90125-7
[119]
A. Roy, J. Sun, R. Mahoney, L. Alonzi, S. Adams, and P. Beling. 2018. Deep learning detecting fraud in credit card transactions. In Proceedings of the 2018 Systems and Information Engineering Design Symposium (SIEDS’18). IEEE Press, Los Alamitos, CA, 129–134. https://doi.org/10.1109/SIEDS.2018.8374722
[120]
Thorsten Schäfer, Jan Jonas, and Mira Mezini. 2008. Mining framework usage changes from instantiation code. In Proceedings of the 30th International Conference on Software Engineering (ICSE’08). Association for Computing Machinery, New York, NY, 471–480. https://doi.org/10.1145/1368088.1368153
[121]
D. Sculley, Gary Holt, Daniel Golovin, Eugene Davydov, Todd Phillips, Dietmar Ebner, Vinay Chaudhary, Michael Young, Jean-Francois Crespo, and Dan Dennison. 2015. Hidden Technical Debt in Machine Learning Systems. MIT Press, Cambridge, MA, 2503–2511.
[122]
Pranab Kumar Sen. 1968. Estimates of the regression coefficient based on Kendall’s Tau. J. Am. Stat. Assoc. 63, 324 (1968), 1379–1389.
[123]
Janice Singer, Susan E. Sim, and Timothy C. Lethbridge. 2008. Software engineering data collection for field studies. In Guide to Advanced Empirical Software Engineering. Springer, 9–34.
[124]
Davide Spadini, Maurício Aniche, and Alberto Bacchelli. 2018. PyDriller: Python framework for mining software repositories. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE’18). Association for Computing Machinery, New York, NY, 908–911. https://doi.org/10.1145/3236024.3264598
[125]
Xiaobing Sun, Tianchi Zhou, Gengjie Li, Jiajun Hu, Hui Yang, and Bin Li. 2017. An empirical study on real bugs for machine learning programs. In Proceedings of the 2017 24th Asia-Pacific Software Engineering Conference (APSEC’17). IEEE Press, Los Alamitos, CA, 348–357. https://doi.org/10.1109/APSEC.2017.41
[126]
Pang-Ning Tan, Michael Steinbach, and Vipin Kumar. 2005. Introduction to Data Mining(1st Ed.). Addison-Wesley Longman Publishing Co., Inc.
[127]
Yiming Tang, Raffi Khatchadourian, Mehdi Bagherzadeh, Rhia Singh, Ajani Stewart, and Anita Raja. 2021. An empirical study of refactorings and technical debt in machine learning systems. In Proceedings of the International Conference on Software Engineering (ICSE’21). ACM/IEEE.
[128]
DVC Team. 2020. Open-source Version Control System for Machine Learning Projects. Retrieved March 26, 2020 from https://dvc.org.
[129]
Cédric Teyton, Jean-Rémy Falleri, Marc Palyart, and Xavier Blanc. 2014. A study of library migrations in Java. J. Softw. Evol. Process 26, 11 (Nov. 2014), 1030–1052. https://doi.org/10.1002/smr.1660
[130]
Ferdian Thung, Shaowei Wang, David Lo, and Lingxiao Jiang. 2012. An empirical study of bugs in machine learning systems. In Proceedings of the 2012 IEEE 23rd International Symposium on Software Reliability Engineering (ISSRE’12). IEEE Press, Los Alamitos, CA, 271–280. https://doi.org/10.1109/ISSRE.2012.22
[131]
Ferdian Thung, Shaowei Wang, David Lo, and Julia Lawall. 2013. Automatic recommendation of API methods from feature requests. In Proceedings of the 28th IEEE/ACM International Conference on Automated Software Engineering (ASE’13). IEEE Press, 290–300.
[132]
Yuchi Tian, Kexin Pei, Suman Jana, and Baishakhi Ray. 2018. DeepTest: Automated testing of deep-neural-network-driven autonomous cars. In Proceedings of the 40th International Conference on Software Engineering (ICSE’18). Association for Computing Machinery, New York, NY, 303–314. https://doi.org/10.1145/3180155.3180220
[133]
Frank Tip, Robert M. Fuhrer, Adam Kieundefinedun, Michael D. Ernst, Ittai Balaban, and Bjorn De Sutter. 2011. Refactoring using type constraints. ACM Trans. Program. Lang. Syst. 33, 3, Article 9 (May 2011), 47 pages. https://doi.org/10.1145/1961204.1961205
[134]
Paolo Tonella. 2003. Using a concept lattice of decomposition slices for program understanding and impact analysis. IEEE Trans. Softw. Eng. 29, 6 (Jun. 2003), 495–509. https://doi.org/10.1109/TSE.2003.1205178
[135]
Weslley Torres, Gustavo Pinto, Benito Fernandes, João Paulo Oliveira, Filipe Alencar Ximenes, and Fernando Castor. 2011. Are Java programmers transitioning to multicore? A large scale study of Java FLOSS. In Proceedings of the Compilation of the Co-Located Workshops on DSM’11, TMC’11, AGERE! 2011, AOOPES’11, NEAT’11, & VMIL’11 (SPLASH’11 Workshops). Association for Computing Machinery, New York, NY, 123–128. https://doi.org/10.1145/2095050.2095072
[136]
Nikolaos Tsantalis, Theodoros Chaikalis, and Alexander Chatzigeorgiou. 2008. JDeodorant: Identification and removal of type-checking bad smells. In Proceedings of the 2008 12th European Conference on Software Maintenance and Reengineering (CSMR’08). IEEE Press, Los Alamitos, CA, 329–331. https://doi.org/10.1109/CSMR.2008.4493342
[137]
Victor L. Winter and Azamat Mametjanov. 2007. Generative programming techniques for Java library migration. In Proceedings of the 6th International Conference on Generative Programming and Component Engineering (GPCE’07). Association for Computing Machinery, New York, NY, 185–196. https://doi.org/10.1145/1289971.1290001
[138]
Claes Wohlin and Aybüke Aurum. 2015. Towards a decision-making structure for selecting a research design in empirical software engineering. Emp. Softw. Eng. 20, 6 (2015), 1427–1455.
[139]
Wei Wu, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Miryung Kim. 2010. AURA: A hybrid approach to identify framework evolution. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering, Volume 1 (ICSE’10). Association for Computing Machinery, New York, NY, 325–334. https://doi.org/10.1145/1806799.1806848
[140]
Zhenchang Xing and Eleni Stroulia. 2007. API-evolution support with Diff-CatchUp. IEEE Trans. Softw. Eng. 33, 12 (Dec. 2007), 818–836. https://doi.org/10.1109/TSE.2007.70747
[141]
Wang Ying, Wen Ming, Liu Yepang, Wang Yibo, Li Zhenming, Wang Chao, Yu Hai, Cheung Shing-Chi, Xu Chang, and Zhu Zhiliang. 2020. Watchman: Monitoring dependency conflicts for Python library ecosystem. In Proceedings of the 42nd International Conference on Software Engineering (ICSE’20). ACM, New York, NY, 11. https://doi.org/10.1145/3377811.3380426
[142]
Zhongxing Yu, Chenggang Bai, Lionel Seinturier, and Martin Monperrus. 2019. Characterizing the usage, evolution and impact of Java annotations in practice. IEEE Trans. Softw. Engin. (2019), 1–1.
[143]
Cheng Zhang, Juyuan Yang, Yi Zhang, Jing Fan, Xin Zhang, Jianjun Zhao, and Peizhao Ou. 2012. Automatic parameter recommendation for practical API usage. In Proceedings of the 34th International Conference on Software Engineering (ICSE’12). IEEE Press, Los Alamitos, CA, 826–836.
[144]
Tianyi Zhang, Cuiyun Gao, Lei Ma, Michael Lyu, and Miryung Kim. 2019. An empirical study of common challenges in developing deep learning applications. In Proceedings of the 2019 IEEE 30th International Symposium on Software Reliability Engineering (ISSRE’19). IEEE Press, Los Alamitos, CA, 104–115. https://doi.org/10.1109/ISSRE.2019.00020
[145]
Yuhao Zhang, Yifan Chen, Shing-Chi Cheung, Yingfei Xiong, and Lu Zhang. 2018. An empirical study on TensorFlow program bugs. In Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA’18). Association for Computing Machinery, New York, NY, 129–140. https://doi.org/10.1145/3213846.3213866
[146]
Shurui Zhou, Bogdan Vasilescu, and Christian Kästner. 2020. How has forking changed in the last 20 years? A study of hard forks on GitHub. In Proceedings of 42nd International Conference on Software Engineering (ICSE’20). ACM, New York, NY, 11. https://doi.org/10.1145/3377811.3380426
[147]
Thomas Zimmermann, Peter Weissgerber, Stephan Diehl, and Andreas Zeller. 2005. Mining version histories to guide software changes. IEEE Trans. Softw. Eng. 31, 6 (Jun. 2005), 429–445. https://doi.org/10.1109/TSE.2005.72

Cited By

View all
  • (2024)DynaMO: Protecting Mobile DL Models through Coupling Obfuscated DL OperatorsProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering10.1145/3691620.3694998(204-215)Online publication date: 27-Oct-2024
  • (2024)Model-less Is the Best Model: Generating Pure Code Implementations to Replace On-Device DL ModelsProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3650212.3652119(174-185)Online publication date: 11-Sep-2024
  • (2024)Unprecedented Code Change Automation: The Fusion of LLMs and Transformation by ExampleProceedings of the ACM on Software Engineering10.1145/36437551:FSE(631-653)Online publication date: 12-Jul-2024
  • Show More Cited By

Index Terms

  1. Understanding Software-2.0: A Study of Machine Learning Library Usage and Evolution

      Recommendations

      Comments

      Information & Contributors

      Information

      Published In

      cover image ACM Transactions on Software Engineering and Methodology
      ACM Transactions on Software Engineering and Methodology  Volume 30, Issue 4
      Continuous Special Section: AI and SE
      October 2021
      613 pages
      ISSN:1049-331X
      EISSN:1557-7392
      DOI:10.1145/3461694
      • Editor:
      • Mauro Pezzè
      Issue’s Table of Contents
      Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

      Publisher

      Association for Computing Machinery

      New York, NY, United States

      Publication History

      Published: 23 July 2021
      Accepted: 01 March 2021
      Revised: 01 January 2021
      Received: 01 July 2020
      Published in TOSEM Volume 30, Issue 4

      Permissions

      Request permissions for this article.

      Check for updates

      Author Tags

      1. Machine learning libraries
      2. Software-2.0
      3. empirical studies

      Qualifiers

      • Research-article
      • Research
      • Refereed

      Funding Sources

      • NSF

      Contributors

      Other Metrics

      Bibliometrics & Citations

      Bibliometrics

      Article Metrics

      • Downloads (Last 12 months)1,183
      • Downloads (Last 6 weeks)144
      Reflects downloads up to 24 Oct 2024

      Other Metrics

      Citations

      Cited By

      View all
      • (2024)DynaMO: Protecting Mobile DL Models through Coupling Obfuscated DL OperatorsProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering10.1145/3691620.3694998(204-215)Online publication date: 27-Oct-2024
      • (2024)Model-less Is the Best Model: Generating Pure Code Implementations to Replace On-Device DL ModelsProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3650212.3652119(174-185)Online publication date: 11-Sep-2024
      • (2024)Unprecedented Code Change Automation: The Fusion of LLMs and Transformation by ExampleProceedings of the ACM on Software Engineering10.1145/36437551:FSE(631-653)Online publication date: 12-Jul-2024
      • (2024)Characterizing Deep Learning Package Supply Chains in PyPI: Domains, Clusters, and DisengagementACM Transactions on Software Engineering and Methodology10.1145/364033633:4(1-27)Online publication date: 10-Jan-2024
      • (2024)Efficient Construction of Practical Python Call Graphs with Entity Knowledge BaseInternational Journal of Software Engineering and Knowledge Engineering10.1142/S021819402450010434:07(999-1024)Online publication date: 22-May-2024
      • (2024)Understanding Newcomers’ Onboarding Process in Deep Learning ProjectsIEEE Transactions on Software Engineering10.1109/TSE.2024.335329750:3(443-460)Online publication date: 1-Mar-2024
      • (2024)Practices for Managing Machine Learning Products: A Multivocal Literature ReviewIEEE Transactions on Engineering Management10.1109/TEM.2023.328775971(7425-7455)Online publication date: 2024
      • (2024)Sustainability Forecasting for Deep Learning Packages2024 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)10.1109/SANER60148.2024.00106(981-992)Online publication date: 12-Mar-2024
      • (2024)Construction of an Intelligent Book Recommendation System for Libraries Under Collaborative Filtering Algorithms2024 International Conference on Data Science and Network Security (ICDSNS)10.1109/ICDSNS62112.2024.10691216(1-6)Online publication date: 26-Jul-2024
      • (2024)Diagnosis of package installation incompatibility via knowledge baseScience of Computer Programming10.1016/j.scico.2024.103098235(103098)Online publication date: Jul-2024
      • Show More Cited By

      View Options

      View options

      PDF

      View or Download as a PDF file.

      PDF

      eReader

      View online with eReader.

      eReader

      HTML Format

      View this article in HTML Format.

      HTML Format

      Get Access

      Login options

      Full Access

      Media

      Figures

      Other

      Tables

      Share

      Share

      Share this Publication link

      Share on social media