International journal of

ADVANCED AND APPLIED SCIENCES

EISSN: 2313-3724, Print ISSN:2313-626X

Frequency: 12
line decor
  
line decor

 Volume 6, Issue 1 (January 2019), Pages: 59-67

----------------------------------------------

 Original Research Paper

 Title: Supporting software documentation with source code summarization

 Author(s): Ra'Fat Al-Msie'deen *, Anas H. Blasi

 Affiliation(s):

 Department of Computer Information Systems, Faculty of IT, Mutah University, P.O. Box 7, Mutah 61710, Karak, Jordan

  Full Text - PDF          XML

 * Corresponding Author. 

  Corresponding author's ORCID profile: https://orcid.org/0000-0002-9559-2293

 Digital Object Identifier: 

 https://doi.org/10.21833/ijaas.2019.01.008

 Abstract:

Source code summarization is a process of generating summaries that describe software code, the majority of source code summarization usually generated manually, where the summaries are written by software developers. Recently, new automated approaches are becoming more useful. These approaches have been found to be effective in some cases. The main weaknesses of these approaches are that they never exploit code dependencies and summarize either the software classes or methods but not both. This paper proposes a source code summarization approach (Suncode) that produces a short description for each class and method in the software system. To validate the approach, it has been applied to several case studies. Moreover, the generated summaries are compared to summaries that written by human experts and to summaries that written by a state-of-the-art solution. Results of this paper found that Suncode summaries provide better information about code dependencies comparing with other studies. In addition, Suncode summaries can improve and support the current software documentation. The results found that manually written summaries were more precise and short as well. 

 © 2018 The Authors. Published by IASE.

 This is an open access article under the CC BY-NC-ND license (http://creativecommons.org/licenses/by-nc-nd/4.0/).

 Keywords: Software engineering, Software documentation, Source code summarization, Software comprehension, Summary

 Article History: Received 11 August 2018, Received in revised form 17 November 2018, Accepted 18 November 2018

 Acknowledgement:

No Acknowledgement

 Compliance with ethical standards

 Conflict of interest:  The authors declare that they have no conflict of interest.

 Citation:

 Al-Msie'deen R and Blasi AH (2019). Supporting software documentation with source code summarization. International Journal of Advanced and Applied Sciences, 6(1): 59-67

 Permanent Link to this page

 Figures

 Fig. 1 Fig. 2 Fig. 3 Fig. 4 Fig. 5

 Tables

 Table 1 Table 2 Table 3 Table 4 Table 5 Table 6 Table 7

----------------------------------------------

 References (25) 

  1. Al-Msie’deen R (2014). Reverse engineering feature models from software variants to build software product lines: REVPLINE approach.  Ph.D.  Dissertation, Universite Montpellier II-Sciences et Techniques du Languedoc, France.   [Google Scholar]
  2. Al-Msie’deen R (2015). Visualizing object-oriented software for understanding and documentation. International Journal of Computer Science and Information Security, 13(5): 18–27.   [Google Scholar]
  3. Al-Msie’deen R (2018). Automatic labeling of the object-oriented source code: The lotus approach. Science International-Lahore, 30(1): 45–48.   [Google Scholar]
  4. Al-Msie’deen R and Blasi A (2018). The impact of the object-oriented software evolution on software metrics: The iris approach. Indian Journal of Science and Technology, 11(8): 1–8. https://doi.org/10.17485/ijst/2018/v11i8/121148   [Google Scholar]
  5. Al-Msie’deen R, Huchard M, Seriai A, Urtado C, and Vauttier S (2014a). Automatic documentation of [mined] feature implementations from source code elements and use- case diagrams with the REVPLINE approach. International Journal of Software Engineering and Knowledge Engineering, 24(10): 1413–1438. https://doi.org/10.1142/S0218194014400142   [Google Scholar]
  6. Al-Msie’deen R, Huchard M, Seriai A, Urtado C, and Vauttier S (2014b). Reverse engineering feature models from software configurations using formal concept analysis. In the Eleventh International Conference on Concept Lattices and Their Applications, Košice, Slovakia: 95–106.   [Google Scholar]
  7. Al-Msie’deen R, Seriai A, Huchard M, Urtado C, and Vauttier S (2013). Mining features from the object-oriented source code of software variants by combining lexical and structural similarity. In the IEEE 14th International Conference on Information Reuse and Integratio, IEEE Computer Society, San Francisco, CA, USA: 586–593. https://doi.org/10.1109/IRI.2013.6642522   [Google Scholar]
  8. Al-Msie’deen R, Seriai A, Huchard M, Urtado C, and Vauttier S (2014c). Documenting the mined feature implementations from the object-oriented source code of a collection of software product variants. In The 26th International Conference on Software Engineering and Knowledge Engineering, Vancouver, Canada, 138–143.   [Google Scholar]
  9. Dave N, Davis D, Potts K, and Asuncion HU (2014). Uncovering file relationships using association mining and topic modeling. In the 6th International Conference on Information, Process, and Knowledge Management, Barcelona, Spain: 105–111.   [Google Scholar]
  10. Forward A and Lethbridge TC (2002). The relevance of software documentation, tools and technologies: A survey. In the 2002 ACM Symposium on Document Engineering, ACM, McLean, Virginia, USA: 26-33. https://doi.org/10.1145/585058.585065   [Google Scholar]
  11. Haiduc S, Aponte J, and Marcus A (2010a). Supporting program comprehension with source code summarization. In the 32nd ACM/IEEE International Conference on Software Engineering, ACM, Cape Town, South Africa, 2: 223-226. https://doi.org/10.1145/1810295.1810335   [Google Scholar]
  12. Haiduc S, Aponte J, Moreno L, and Marcus A (2010b). On the use of automated text summarization techniques for summarizing source code. In the 17th Working Conference on Reverse Engineering (WCRE), IEEE, Beverly, USA: 35-44. https://doi.org/10.1109/WCRE.2010.13   [Google Scholar]
  13. Kanellopoulos Y, Dimopulos T, Tjortjis C, and Makris C (2006). Mining source code elements for comprehending object-oriented systems and evaluating their maintainability. SIGKDD Explorations, 8(1): 33–40. https://doi.org/10.1145/1147234.1147240   [Google Scholar]
  14. Ko AJ, Myers BA, Coblenz MJ, and Aung HH (2006). An exploratory study of how developers seek, relate, and collect relevant information during software maintenance tasks. IEEE Transactions on software Engineering, 32(12): 971-987. https://doi.org/10.1109/TSE.2006.116   [Google Scholar]
  15. LaToza TD, Venolia G, and DeLine R (2006). Maintaining mental models: A study of developer work habits. In the 28th International Conference on Software Engineering, ACM, Shanghai, China, 492–501. https://doi.org/10.1145/1134285.1134355   [Google Scholar]
  16. McBurney PW and McMillan C (2014). Automatic documentation generation via source code summarization of method context. In the 22nd International Conference on Program Comprehension, ACM, Hyderabad, India: 279-290. https://doi.org/10.1145/2597008.2597149   [Google Scholar]
  17. McBurney PW and McMillan C (2016a). Automatic source code summarization of context for java methods. IEEE Transactions on Software Engineering, 42(2): 103-119. https://doi.org/10.1109/TSE.2015.2465386   [Google Scholar]
  18. McBurney PW and McMillan C (2016b). An empirical study of the textual similarity between source code and source code summaries. Empirical Software Engineering, 21(1): 17-42. https://doi.org/10.1007/s10664-014-9344-6   [Google Scholar]
  19. Moreno L, Aponte J, Sridhara G, Marcus A, Pollock L, and Vijay-Shanker K (2013a). Automatic generation of natural language summaries for java classes. In the IEEE 21st International Conference on Program Comprehension, IEEE, San Francisco, USA: 23-32. https://doi.org/10.1109/ICPC.2013.6613830   [Google Scholar]
  20. Moreno L, Marcus A, Pollock L, and Vijay-Shanker K (2013b). Jsummarizer: An automatic generator of natural language summaries for java classes. In IEEE 21st International Conference on Program Comprehension, IEEE, San Francisco, USA: 230-232. https://doi.org/10.1109/ICPC.2013.6613855   [Google Scholar]
  21. Radev DR, Hovy EH, and McKeown KR (2002). Introduction to the special issue on summarization. Computational Linguistics, 28(4): 399–408. https://doi.org/10.1162/089120102762671927   [Google Scholar]
  22. Roehm T, Tiarks R, Koschke R, and Maalej W (2012). How do professional developers comprehend software?. In the 34th International Conference on Software Engineering, IEEE, Zurich, Switzerland: 255-265. https://doi.org/10.1109/ICSE.2012.6227188   [Google Scholar]
  23. Shi L, Zhong H, Xie T, and Li M (2011). An empirical study on evolution of API documentation. In the International Conference on Fundamental Approaches to Software Engineering, Springer, Berlin, Heidelberg, Germany: 416-431. https://doi.org/10.1007/978-3-642-19811-3_29   [Google Scholar]
  24. Sridhara G, Hill E, Muppaneni D, Pollock L, and Vijay-Shanker K (2010). Towards automatically generating summary comments for java methods. In the IEEE/ACM International Conference on Automated Software Engineering, ACM, Antwerp, Belgium: 43-52. https://doi.org/10.1145/1858996.1859006   [Google Scholar]
  25. Yau SS and Collofello JS (1980). Some stability measures for software maintenance. IEEE Transactions on Software Engineering, 6(6): 545-552. https://doi.org/10.1109/TSE.1980.234503   [Google Scholar]