research-article

Open access

A Hybrid Approach for Inference between Behavioral Exception API Documentation and Implementations, and Its Applications

Authors:

Hoan Anh Nguyen,

Hung Dang Phan,

Samantha Syeda Khairunnesa,

Aashish Yadavally,

Tien NguyenAuthors Info & Claims

ASE '22: Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering

Article No.: 2, Pages 1 - 13

https://doi.org/10.1145/3551349.3560434

Published: 05 January 2023 Publication History

All formats PDF

Abstract

Automatically producing behavioral exception (BE) API documentation helps developers correctly use the libraries. The state-of-the-art approaches are either rule-based, which is too restrictive in its applicability, or deep learning (DL)-based, which requires large training dataset. To address that, we propose StatGen, a novel hybrid approach between statistical machine translation (SMT) and tree-structured translation to generate the BE documentation for any code and vice versa. We consider the documentation and source code of an API method as the two abstraction levels of the same intent. StatGen is specifically designed for this two-way inference, and takes advantage of their structures for higher accuracy.

We conducted several experiments to evaluate StatGen. We show that it achieves high precision (75% and 75%), and recall (81% and 84%), in inferring BE documentation from source code and vice versa. StatGen achieves higher precision, recall, and BLEU score than the state-of-the-art, DL-based baseline models. We show StatGen’s usefulness in two applications. First, we use it to generate the BE documentation for Apache APIs that lack of documentation by learning from the documentation of the equivalent APIs in JDK. 44% of the generated documentation were rated as useful and 42% as somewhat useful. In the second application, we use StatGen to detect the inconsistency between the BE documentation and corresponding implementations of several JDK8 packages.

References

[1]

2022. Statgen. https://nguyenhoan.github.io/statgen/

[2]

Matthew Allen and Susan Horwitz. 2003. Slicing Java Programs That Throw and Catch Exceptions. In Proceedings of the 2003 ACM SIGPLAN Workshop on Partial Evaluation and Semantics-Based Program Manipulation(PEPM ’03). Association for Computing Machinery, 44–54. https://doi.org/10.1145/966049.777394

Digital Library

[3]

Glenn Ammons, Rastislav Bodík, and James R. Larus. 2002. Mining Specifications. In Proceedings of the 29th ACM SIGPLAN SIGACT Symposium on Principles of Programming Languages (Portland, Oregon) (POPL ’02). ACM, 4–16. https://doi.org/10.1145/503272.503275

Digital Library

[4]

Ivan Beschastnikh, Yuriy Brun, Jenny Abrahamson, Michael D. Ernst, and Arvind Krishnamurthy. 2013. Unifying FSM-inference Algorithms Through Declarative Specification. In Proceedings of the 2013 International Conference on Software Engineering(ICSE ’13). IEEE Press, 252–261.

Digital Library

[5]

I. Beschastnikh, Y. Brun, J. Abrahamson, M. D. Ernst, and A. Krishnamurthy. 2015. Using Declarative Specification to Improve the Understanding, Extensibility, and Comparison of Model-Inference Algorithms. IEEE Transactions on Software Engineering 41, 4 (April 2015), 408–428.

Digital Library

[6]

Ivan Beschastnikh, Yuriy Brun, Michael D. Ernst, and Arvind Krishnamurthy. 2014. Inferring Models of Concurrent Systems from Logs of Their Behavior with CSight. In Proceedings of the 36th International Conference on Software Engineering(ICSE 2014). ACM, 468–479.

Digital Library

[7]

Ivan Beschastnikh, Yuriy Brun, Sigurd Schneider, Michael Sloan, and Michael D. Ernst. 2011. Leveraging Existing Instrumentation to Automatically Infer Invariant-constrained Models. In Proceedings of the 19th Symposium on Foundations of Software Engineering (Szeged, Hungary) (ESEC/FSE ’11). ACM, 267–277. https://doi.org/10.1145/2025113.2025151

Digital Library

[8]

Arianna Blasi, Alberto Goffi, Konstantin Kuznetsov, Alessandra Gorla, Michael D. Ernst, Mauro Pezzè, and Sergio Delgado Castellanos. 2018. Translating Code Comments to Procedure Specifications. In Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis(ISSTA 2018). ACM, 242–253.

Digital Library

[9]

Raymond P.L. Buse and Westley R. Weimer. 2010. Automatically Documenting Program Changes. In Proceedings of the IEEE/ACM International Conference on Automated Software Engineering(ASE ’10). ACM, 33–42.

[10]

Daniel Cer, Michel Galley, Daniel Jurafsky, and Christopher D. Manning. 2010. Phrasal: A Statistical Machine Translation Toolkit for Exploring New Model Features. In Proceedings of the NAACL HLT 2010 Demonstration Session. Association for Computational Linguistics, Los Angeles, California, 9–12.

[11]

Xinyun Chen, Chang Liu, and Dawn Song. 2018. Tree-to-Tree Neural Networks for Program Translation. In Proceedings of the 32nd International Conference on Neural Information Processing Systems(NIPS’18). Curran Associates Inc., 2552–2562.

Digital Library

[12]

Barthélémy Dagenais and Martin P. Robillard. 2010. Creating and Evolving Developer Documentation: Understanding the Decisions of Open Source Contributors. In Proceedings of the Eighteenth ACM SIGSOFT International Symposium on Foundations of Software Engineering(FSE ’10). ACM, 127–136.

Digital Library

[13]

Leonardo De Moura and Nikolaj Bjørner. 2008. Z3: An Efficient SMT Solver. In Proceedings of the Theory and Practice of Software, 14th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (Budapest, Hungary) (TACAS’08/ETAPS’08). Springer-Verlag, Berlin, Heidelberg, 337–340. http://dl.acm.org/citation.cfm?id=1792734.1792766

[14]

Dawson Engler, David Yu Chen, Seth Hallem, Andy Chou, and Benjamin Chelf. 2001. Bugs As Deviant Behavior: A General Approach to Inferring Errors in Systems Code. In Proceedings of the Eighteenth ACM Symposium on Operating Systems Principles (Banff, Alberta, Canada) (SOSP’01). ACM, 57–72. https://doi.org/10.1145/502034.502041

Digital Library

[15]

Michael D. Ernst, Jake Cockrell, William G. Griswold, and David Notkin. 1999. Dynamically Discovering Likely Program Invariants to Support Program Evolution. In Proceedings of the 21st International Conference on Software Engineering (Los Angeles, California, USA) (ICSE’99). ACM, 213–224. https://doi.org/10.1145/302405.302467

Digital Library

[16]

Mark Gabel and Zhendong Su. 2008. Javert: Fully Automatic Mining of General Temporal Properties from Dynamic Traces. In Proceedings of the 16th ACM SIGSOFT International Symposium on Foundations of Software Engineering (Atlanta, Georgia) (SIGSOFT ’08/FSE-16). ACM, 339–349. https://doi.org/10.1145/1453101.1453150

Digital Library

[17]

Carlo Ghezzi, Mauro Pezzè, Michele Sama, and Giordano Tamburrelli. 2014. Mining Behavior Models from User-intensive Web Applications. In Proceedings of the 36th International Conference on Software Engineering(ICSE 2014). ACM, 277–287.

Digital Library

[18]

Alberto Goffi, Alessandra Gorla, Michael D. Ernst, and Mauro Pezzè. 2016. Automatic Generation of Oracles for Exceptional Behaviors. In Proceedings of the 25th International Symposium on Software Testing and Analysis(ISSTA 2016). ACM, 213–224.

Digital Library

[19]

Xiaodong Gu, Hongyu Zhang, Dongmei Zhang, and Sunghun Kim. 2016 (To appear). Deep API Learning. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering(FSE 2016). ACM.

[20]

Tihomir Gvero and Viktor Kuncak. 2015. Synthesizing Java Expressions from Free-form Queries. In Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications (Pittsburgh, PA, USA) (OOPSLA 2015). ACM, New York, NY, USA, 416–432. https://doi.org/10.1145/2814270.2814295

Digital Library

[21]

Hideaki Hata, Emad Shihab, and Graham Neubig. 2018. Learning to Generate Corrective Patches using Neural Machine Translation. CoRR abs/1812.07170(2018). arxiv:1812.07170http://arxiv.org/abs/1812.07170

[22]

Xing Hu, Ge Li, Xin Xia, D. Lo, and Zhi Jin. 2019. Deep code comment generation with hybrid lexical and syntactical information. Empirical Software Engineering 25 (2019), 2179–2217.

Digital Library

[23]

Srini Iyer, Ioannis Konstas, Alvin Cheung, and Luke Zettlemoyer. 2016. Summarizing Source Code using a Neural Attention Model. In ACL.

[24]

Alan Jaffe, Jeremy Lacomis, Edward J. Schwartz, Claire Le Goues, and Bogdan Vasilescu. 2018. Meaningful Variable Names for Decompiled Code: A Machine Translation Approach. In Proceedings of the 26th Conference on Program Comprehension(ICPC ’18). ACM, 20–30.

Digital Library

[25]

Dan Klein and Christopher D. Manning. 2003. Accurate Unlexicalized Parsing. In Proceedings of the 41st Annual Meeting on Association for Computational Linguistics - Volume 1(ACL ’03). Association for Computational Linguistics, 423–430.

Digital Library

[26]

Philipp Koehn. 2010. Statistical Machine Translation(1st ed.). Cambridge University Press, New York, NY, USA.

[27]

Ted Kremenek, Paul Twohey, Godmar Back, Andrew Ng, and Dawson Engler. 2006. From uncertainty to belief: inferring the specification within. In Proceedings of the 7th symposium on Operating systems design and implementation(OSDI ’06). USENIX Association, 161–176.

[28]

Ivo Krka, Yuriy Brun, and Nenad Medvidovic. 2014. Automatic Mining of Specifications from Invocation Traces and Method Invariants. In Proceedings of the 22Nd ACM SIGSOFT International Symposium on Foundations of Software Engineering(FSE 2014). ACM, 178–189.

Digital Library

[29]

T. B. Le, X. D. Le, D. Lo, and I. Beschastnikh. 2015. Synergizing Specification Miners through Model Fissions and Fusions (T). In 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE). 115–125.

[30]

Tao Lei, Fan Long, Regina Barzilay, and Martin C. Rinard. 2013. From Natural Language Specifications to Program Input Parsers. In ACL.

[31]

Zhenmin Li and Yuanyuan Zhou. 2005. PR-Miner: Automatically Extracting Implicit Programming Rules and Detecting Violations in Large Software Code. In Proceedings of the 13th Symposium on Foundations of Software Engineering (Lisbon, Portugal) (ESEC/FSE-13). ACM, 306–315. https://doi.org/10.1145/1081706.1081755

Digital Library

[32]

Benjamin Livshits and Thomas Zimmermann. 2005. DynaMine: finding common error patterns by mining software revision histories. SIGSOFT Softw. Eng. Notes 30, 5 (2005), 296–305.

Digital Library

[33]

D. Lo and S. Khoo. 2006. QUARK: Empirical Assessment of Automaton-based Specification Miners. In 2006 13th Working Conference on Reverse Engineering. 51–60.

[34]

David Lo and Siau-Cheng Khoo. 2006. SMArTIC: Towards Building an Accurate, Robust and Scalable Specification Miner. In Proceedings of the 14th ACM SIGSOFT International Symposium on Foundations of Software Engineering(SIGSOFT ’06/FSE-14). ACM, 265–275.

Digital Library

[35]

David Lo and Shahar Maoz. 2010. Scenario-based and Value-based Specification Mining: Better Together. In Proceedings of the IEEE/ACM International Conference on Automated Software Engineering(ASE ’10). ACM, 387–396.

Digital Library

[36]

David Lo, Leonardo Mariani, and Mauro Pezzè. 2009. Automatic Steering of Behavioral Model Inference. In Proceedings of the 7th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on The Foundations of Software Engineering(ESEC/FSE ’09). ACM, 345–354.

Digital Library

[37]

David Lo, Leonardo Mariani, and Mauro Santoro. 2012. Learning Extended FSA from Software: An Empirical Assessment. J. Syst. Softw. 85, 9 (Sept. 2012), 2063–2076.

[38]

Pablo Loyola, Edison Marrese-Taylor, and Yutaka Matsuo. 2017. A Neural Architecture for Generating Natural Language Descriptions from Source Code Changes. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 2: Short Papers, Regina Barzilay and Min-Yen Kan (Eds.). Association for Computational Linguistics, 287–292. https://doi.org/10.18653/v1/P17-2045

[39]

Junayed Mahmud, Fahim Faisal, Raihan Islam Arnob, Antonios Anastasopoulos, and Kevin Moran. 2021. Code to Comment Translation: A Comparative Study on Model Effectiveness & Errors. In Proceedings of the 1st Workshop on Natural Language Processing for Programming (NLP4Prog 2021). Association for Computational Linguistics, Online, 1–16. https://doi.org/10.18653/v1/2021.nlp4prog-1.1

[40]

Leonardo Mariani and Fabrizio Pastore. 2008. Automated Identification of Failure Causes in System Logs. In Proceedings of the 2008 19th International Symposium on Software Reliability Engineering(ISSRE ’08). IEEE Computer Society, 117–126. https://doi.org/10.1109/ISSRE.2008.48

Digital Library

[41]

Sarah Nadi, Stefan Krüger, Mira Mezini, and Eric Bodden. 2016. Jumping Through Hoops: Why Do Java Developers Struggle with Cryptography APIs?. In Proceedings of the 38th International Conference on Software Engineering (Austin, Texas) (ICSE ’16). ACM, New York, NY, USA, 935–946. https://doi.org/10.1145/2884781.2884790

Digital Library

[42]

Hoan Anh Nguyen, Robert Dyer, Tien N. Nguyen, and Hridesh Rajan. 2014. Mining Preconditions of APIs in Large-scale Code Corpus. In Proceedings of the 22Nd ACM SIGSOFT International Symposium on Foundations of Software Engineering(FSE 2014). ACM, 166–177.

Digital Library

[43]

H. A. Nguyen, T. T. Nguyen, N. H. Pham, J. M. Al-Kofahi, and T. N. Nguyen. 2009. Accurate and Efficient Structural Characteristic Feature Extraction for Clone Detection. In FASE ’09. Springer Verlag, 440–455.

[44]

Tung Thanh Nguyen, Hoan Anh Nguyen, Nam H. Pham, Jafar M. Al-Kofahi, and Tien N. Nguyen. 2009. Graph-based Mining of Multiple Object Usage Patterns. In Proceedings of Conference on the Foundations of Software Engineering(ESEC/FSE ’09). ACM, 383–392.

Digital Library

[45]

Yusuke Oda, Hiroyuki Fudaba, Graham Neubig, Hideaki Hata, Sakriani Sakti, Tomoki Toda, and Satoshi Nakamura. 2015. Learning to Generate Pseudo-Code from Source Code Using Statistical Machine Translation (T). In Proceedings of the 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE)(ASE ’15). IEEE Computer Society, 574–584.

Digital Library

[46]

Tony Ohmann, Michael Herzberg, Sebastian Fiss, Armand Halbert, Marc Palyart, Ivan Beschastnikh, and Yuriy Brun. 2014. Behavioral Resource-aware Model Inference. In Proceedings of the 29th ACM/IEEE International Conference on Automated Software Engineering(ASE ’14). ACM, 19–30.

Digital Library

[47]

H. Phan, H. A. Nguyen, T. N. Nguyen, and H. Rajan. 2017. Statistical Learning for Inference between Implementations and Documentation. In 2017 IEEE/ACM 39th International Conference on Software Engineering: New Ideas and Emerging Technologies Results Track (ICSE-NIER). 27–30. https://doi.org/10.1109/ICSE-NIER.2017.9

Digital Library

[48]

Michael Pradel and Thomas R. Gross. 2009. Automatic Generation of Object Usage Specifications from Large Method Traces. In Proceedings of the 2009 IEEE/ACM International Conference on Automated Software Engineering(ASE ’09). IEEE Computer Society, 371–382. https://doi.org/10.1109/ASE.2009.60

Digital Library

[49]

Mukund Raghothaman, Yi Wei, and Youssef Hamadi. 2016. SWIM: Synthesizing What I Mean. In Proceedings of the 38th International Conference on Software Engineering(ICSE 2016). ACM Press.

Digital Library

[50]

Murali Krishna Ramanathan, Ananth Grama, and Suresh Jagannathan. 2007. Static Specification Inference Using Predicate Mining. In Proceedings of the 2007 ACM SIGPLAN Conference on Programming Language Design and Implementation (San Diego, California, USA) (PLDI ’07). ACM, 123–134. https://doi.org/10.1145/1250734.1250749

Digital Library

[51]

S. P. Reiss and M. Renieris. 2001. Encoding program executions. In Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001. IEEE CS, 221–230.

[52]

Matthias Schur, Andreas Roth, and Andreas Zeller. 2013. Mining Behavior Models from Enterprise Web Applications. In Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering(ESEC/FSE 2013). ACM, 422–432.

Digital Library

[53]

Giriprasad Sridhara, Emily Hill, Divya Muppaneni, Lori Pollock, and K. Vijay-Shanker. 2010. Towards Automatically Generating Summary Comments for Java Methods. In Proceedings of the IEEE/ACM International Conference on Automated Software Engineering(ASE ’10). ACM, 43–52.

[54]

Siddharth Subramanian, Laura Inozemtseva, and Reid Holmes. 2014. Live API Documentation. In Proceedings of the 36th International Conference on Software Engineering (Hyderabad, India) (ICSE 2014). 643–652.

Digital Library

[55]

Zeyu Sun, Qihao Zhu, Lili Mou, Yingfei Xiong, Ge Li, and Lu Zhang. 2019. A Grammar-Based Structural CNN Decoder for Code Generation. In Proceedings of the Thirty-Third AAAI Conference on Artificial Intelligence and Thirty-First Innovative Applications of Artificial Intelligence Conference and Ninth AAAI Symposium on Educational Advances in Artificial Intelligence (Honolulu, Hawaii, USA) (AAAI’19/IAAI’19/EAAI’19). AAAI Press, Article 866, 8 pages. https://doi.org/10.1609/aaai.v33i01.33017055

Digital Library

[56]

Zeyu Sun, Qihao Zhu, Yingfei Xiong, Yican Sun, Lili Mou, and Lu Zhang. 2020. TreeGen: A Tree-Based Transformer Architecture for Code Generation. In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020, The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY, USA, February 7-12, 2020. AAAI Press, 8984–8991. https://ojs.aaai.org/index.php/AAAI/article/view/6430

[57]

Shin Hwei Tan, Darko Marinov, Lin Tan, and Gary T. Leavens. 2012. @tComment: Testing Javadoc Comments to Detect Comment-Code Inconsistencies. In Proceedings of the 2012 IEEE Fifth International Conference on Software Testing, Verification and Validation(ICST ’12). IEEE CS, 260–269.

Digital Library

[58]

Suresh Thummalapenta and Tao Xie. 2009. Alattin: Mining Alternative Patterns for Detecting Neglected Conditions. In Proceedings of the 2009 IEEE/ACM International Conference on Automated Software Engineering(ASE ’09). IEEE Computer Society, 283–294. https://doi.org/10.1109/ASE.2009.72

Digital Library

[59]

Michele Tufano, Jevgenija Pantiuchina, Cody Watson, Gabriele Bavota, and Denys Poshyvanyk. 2019. On Learning Meaningful Code Changes via Neural Machine Translation. In Proceedings of the 41st International Conference on Software Engineering(ICSE ’19). IEEE Press, 25–36.

Digital Library

[60]

Andrzej Wasylkowski and Andreas Zeller. 2009. Mining Temporal Specifications from Object Usage. In Proceedings of the 2009 IEEE/ACM International Conference on Automated Software Engineering(ASE ’09). IEEE Computer Society, 295–306. https://doi.org/10.1109/ASE.2009.30

Digital Library

[61]

Andrzej Wasylkowski, Andreas Zeller, and Christian Lindig. 2007. Detecting Object Usage Anomalies. In Proceedings of the Symposium on Foundations of Software Engineering (Dubrovnik, Croatia) (ESEC-FSE ’07). ACM, 35–44. https://doi.org/10.1145/1287624.1287632

Digital Library

[62]

Bolin Wei, Ge Li, Xin Xia, Zhiyi Fu, and Zhi Jin. 2019. Code Generation as a Dual Task of Code Summarization. Curran Associates Inc., Red Hook, NY, USA.

[63]

Yi Wei, Carlo A. Furia, Nikolay Kazmin, and Bertrand Meyer. 2011. Inferring Better Contracts. In Proceedings of the 33rd International Conference on Software Engineering (Waikiki, Honolulu, HI, USA) (ICSE ’11). ACM, 191–200. https://doi.org/10.1145/1985793.1985820

Digital Library

[64]

Westley Weimer and George C. Necula. 2005. Mining Temporal Specifications for Error Detection. In Proceedings of the 11th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (Edinburgh, UK) (TACAS’05). Springer-Verlag, 461–476. https://doi.org/10.1007/978-3-540-31980-1_30

Digital Library

[65]

Chadd C. Williams and Jeffrey K. Hollingsworth. 2005. Automatic Mining of Source Code Repositories to Improve Bug Finding Techniques. IEEE Trans. Softw. Eng. 31, 6 (2005), 466–480.

Digital Library

[66]

Claes Wohlin, Per Runeson, Martin Hst, Magnus C. Ohlsson, Bjrn Regnell, and Anders Wessln. 2012. Experimentation in Software Engineering. Springer Publishing Company, Incorporated.

[67]

Jinlin Yang, David Evans, Deepali Bhardwaj, Thirumalesh Bhat, and Manuvir Das. 2006. Perracotta: Mining Temporal API Rules from Imperfect Traces. In Proceedings of the 28th International Conference on Software Engineering (Shanghai, China) (ICSE ’06). ACM, 282–291. https://doi.org/10.1145/1134285.1134325

Digital Library

[68]

Juan Zhai, Jianjun Huang, Shiqing Ma, Xiangyu Zhang, Lin Tan, Jianhua Zhao, and Feng Qin. 2016. Automatic Model Generation from Documentation for Java API Functions. In Proceedings of the 38th International Conference on Software Engineering(ICSE ’16). ACM, 380–391.

Digital Library

[69]

Juan Zhai, Yu Shi, Minxue Pan, Guian Zhou, Yongxiang Liu, Chunrong Fang, Shiqing Ma, Lin Tan, and Xiangyu Zhang. 2020. C2S: Translating Natural Language Comments to Formal Program Specifications. In Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering(ESEC/FSE 2020). Association for Computing Machinery, New York, NY, USA, 25–37. https://doi.org/10.1145/3368089.3409716

Digital Library

[70]

Hao Zhong, Tao Xie, Lu Zhang, Jian Pei, and Hong Mei. 2009. MAPO: Mining and Recommending API Usage Patterns. In Proceedings of the 23rd European Conference on ECOOP 2009 — Object-Oriented Programming. Springer-Verlag, 318–343.

Digital Library

[71]

Yu Zhou, Ruihang Gu, Taolue Chen, Zhiqiu Huang, Sebastiano Panichella, and Harald Gall. 2017. Analyzing APIs Documentation and Code to Detect Directive Defects. In Proceedings of the 39th International Conference on Software Engineering(ICSE ’17). IEEE Press, 27–37.

Digital Library

Cited By

Nguyen SVu TVo H(2023)VFFINDER: A Graph-Based Approach for Automated Silent Vulnerability-Fix Identification2023 15th International Conference on Knowledge and Systems Engineering (KSE)10.1109/KSE59128.2023.10299438(1-6)Online publication date: 18-Oct-2023
https://doi.org/10.1109/KSE59128.2023.10299438
Marcilio DFuria C(2023)Towards Code Improvements Suggestions from Client Exception Analysis2023 IEEE International Conference on Software Maintenance and Evolution (ICSME)10.1109/ICSME58846.2023.00046(363-368)Online publication date: 1-Oct-2023
https://doi.org/10.1109/ICSME58846.2023.00046
Vo HNguyen S(2023)Can an old fashioned feature extraction and a light-weight model improve vulnerability type identification performance?Information and Software Technology10.1016/j.infsof.2023.107304164:COnline publication date: 1-Dec-2023
https://dl.acm.org/doi/10.1016/j.infsof.2023.107304

Index Terms

A Hybrid Approach for Inference between Behavioral Exception API Documentation and Implementations, and Its Applications
1. Software and its engineering
  1. Software organization and properties
    1. Software functional properties
      1. Formal methods
        Software verification

Recommendations

API documentation and software community values: a survey of open-source API documentation
SIGDOC '13: Proceedings of the 31st ACM international conference on Design of communication

Studies of what software developers need from API documentation have reported consistent findings over the years; however, these studies all used similar methods--usually a form of observation or survey. Our study looks at API documentation as artifacts ...
Live API documentation
ICSE 2014: Proceedings of the 36th International Conference on Software Engineering

Application Programming Interfaces (APIs) provide powerful abstraction mechanisms that enable complex functionality to be used by client programs. However, this abstraction does not come for free: understanding how to use an API can be difficult. While ...
Aspect-oriented generation of the API documentation for AspectJ
DSAL '09: Proceedings of the 4th workshop on Domain-specific aspect languages

Through the development of a framework or a class library, writing the document on their application programming interface (API) is essential. The document on the API, which we call the API documentation, is mainly read by programmers who want to develop ...

Comments

Information & Contributors

Information

Published In

cover image ACM Other conferences

ASE '22: Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering

October 2022

2006 pages

ISBN:9781450394758

DOI:10.1145/3551349

Copyright © 2022 ACM.

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: 05 January 2023

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article
Research
Refereed limited

Funding Sources

Conference

ASE '22

ASE '22: 37th IEEE/ACM International Conference on Automated Software Engineering

October 10 - 14, 2022

MI, Rochester, USA

Acceptance Rates

Overall Acceptance Rate 82 of 337 submissions, 24%

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

3
Total Citations
View Citations
622
Total Downloads

Downloads (Last 12 months)274
Downloads (Last 6 weeks)31

Reflects downloads up to 01 Jan 2025

Other Metrics

View Author Metrics

Citations

Cited By

Nguyen SVu TVo H(2023)VFFINDER: A Graph-Based Approach for Automated Silent Vulnerability-Fix Identification2023 15th International Conference on Knowledge and Systems Engineering (KSE)10.1109/KSE59128.2023.10299438(1-6)Online publication date: 18-Oct-2023
https://doi.org/10.1109/KSE59128.2023.10299438
Marcilio DFuria C(2023)Towards Code Improvements Suggestions from Client Exception Analysis2023 IEEE International Conference on Software Maintenance and Evolution (ICSME)10.1109/ICSME58846.2023.00046(363-368)Online publication date: 1-Oct-2023
https://doi.org/10.1109/ICSME58846.2023.00046
Vo HNguyen S(2023)Can an old fashioned feature extraction and a light-weight model improve vulnerability type identification performance?Information and Software Technology10.1016/j.infsof.2023.107304164:COnline publication date: 1-Dec-2023
https://dl.acm.org/doi/10.1016/j.infsof.2023.107304

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

HTML Format

View this article in HTML Format.

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

Media

Figures

Other

Tables

View Table of Contents