Metrics to understand future maintenance effort required of a complicated source code
DOI:
https://doi.org/10.26439/ciis2019.5510Keywords:
analysis, metrics, complex, complicated, source codeAbstract
An enduring engineering problem is the creation of a source code too complicated for humans to review and understand. A consequence of a complicated source code is that it requires more effort to be implemented and maintained. Exacerbating the problem is a lack of a proper understanding of exactly what the words “complicated” and “complex” mean, as the definitions of these words are often misconstrued. Some systems are indeed inherently complex, but this does not mean they must be complicated. In our research, several opensource projects were evaluated using software metrics to map the complicatedness of a source code with the ongoing effort to sustain the project. The results of our research show that a relationship exists between a complicated source code and the maintenance effort. It is clear that adhering to proper coding practices and avoiding a complicated code can result in a much more manageable future maintenance effort.
Downloads
References
Bardas, A. G. (2010). Static code analysis. Journal of Information Systems & Operations Management, 4(2), 99-107.
Borowiec, D. (2014). Commented Code Detector. Retrieved June 16, 2019, from https:// https://github.com/dborowiec/commentedCodeDetector
Dorin, M. (2018, May). Coding for inspections and reviews. In Proceedings of the 19th International Conference on Agile Software Development: Companion (p. 34). ACM.
Foucault, M., Palyart, M., Blanc, X., Murphy, G. C., & Falleri, J. R. (2015, August). Impact of developer turnover on quality in open-source software. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering (pp. 829-841). ACM.
GitHub. (2019). Build software better, together. Retrieved June 16, from https://github.com/
Halstead, M. H. (1977). Elements of software science (Vol. 7, p. 127). New York: Elsevier.
Hatton, L. (1997). Reexamining the fault density component size connection. IEEE software, 14(2), 89-97.
Kobashi, Y., Fukuda, M., Yoshida, K., Miyashita, N., Niki, Y., & Oka, M. (2006). Chronic necrotizing pulmonary aspergillosis as a complication of pulmonary Mycobacterium avium complex disease. Respirology, 11(6), 809-813.
Lissack, M., & Roos, J. (1999). The next common sense: Mastering corporate complexity through coherence. Nicholas Brealey Publishing.
Manser, M. (2004). Good Word Guide. Bloomsbury Publishing UK.
Marjamäki , D. (2019). Cppcheck. Retrieved June 16, 2019, from http://cppcheck.sourceforge.net
McCabe, T. J. (1976). A complexity measure. IEEE Transactions on software Engineering, (4), 308-320.
Mish, F. C. (Ed.). (2004). Merriam-Webster’s collegiate dictionary. Merriam-Webster.
Nagappan, N., & Ball , T. (2005, May). Use of relative code churn measures to predict system defect density. In Proceedings of the 27th international conference on Software engineering (pp. 284-292). ACM.
Spinellis, D. (2012). Git. IEEE software, 29(3), 100-101.
Sturtevant, D. J. (2013). System design and the cost of architectural complexity (Doctoral dissertation, Massachusetts Institute of Technology).
Torek, A. C. Distributed Version Control With Git And Mercurial. Retrieved June 16, 2019,
from http://web.torek.net/torek/tmp/book.pdf
Yin, T. (2019). Lizard. Retrieved June 16, 2019, from https://github.com/terryyin/lizard
Yoon and K. Tyagi. (2014) nsiqcppstyle. Retrieved June 16, 2019, from https://github.com/kunaltyagi/nsiqcppstyle
