Ewan Tempero
Kelly Blincoe
Danielle Lottridge
ABSTRACT
Good modularity is seen as an important goal in software design. Achieving this goal is claimed to improve, among other things, the understandability and modifiability of a design. Yet, when teaching software design, we see that students limit the amount of modularity that they introduce into their code and cannot see the benefit of further modularity. This could be because they do not understand the benefits, but it could also be that these benefits are limited for inexperienced developers. In order to teach the benefits of modularity we need to understand what, if any, benefits exist for students. We conducted a controlled experiment where 40 students performed a modification task on two different designs, one with higher modularity than the other. Students were better able to successfully complete the task with the design with higher modularity. However, we found a trend where understanding was lower for the high modularity design. These results suggest modularity is beneficial to students, and that understanding of modularity needs to be better supported when teaching software design.
- Edward V. Berard. 1993. Essays on object-oriented software engineering (vol. 1). Prentice-Hall, Inc.Google Scholar
- Andrew P. Black, Kim B. Bruce, Michael Homer, James Noble, Amy Ruskin, and Richard Yannow. 2013. Seeking Grace: A New Object-Oriented Language for Novices. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (Denver, Colorado, USA) (SIGCSE ’13). Association for Computing Machinery, New York, NY, USA, 129–134. https://doi.org/10.1145/2445196.2445240Google ScholarDigital Library
- Barry W Boehm, John R Brown, and Myron Lipow. 1976. Quantitative evaluation of software quality. In Proceedings of the 2nd International Conference on Software Engineering. 592–605.Google ScholarDigital Library
- B. W. Boehm, J. R. Brown, M. Lipow, G. J. MacLeod, and M. J. Merritt. 1978. Characteristics of Software Quality. Elsevier North-Holland.Google Scholar
- Grady Booch. 1994. Object-Oriented Analysis and Design: with Applications (2nd ed.). Addison-Wesley.Google Scholar
- Kim B. Bruce. 2004. Controversy on How to Teach CS 1: A Discussion on the SIGCSE-Members Mailing List. In Working Group Reports from ITiCSE on Innovation and Technology in Computer Science Education (Leeds, United Kingdom) (ITiCSE-WGR ’04). Association for Computing Machinery, New York, NY, USA, 29–34. https://doi.org/10.1145/1044550.1041652Google ScholarDigital Library
- Yuanfang Cai, Daniel Iannuzzi, and Sunny Wong. 2011. Leveraging design structure matrices in software design education. In 2011 24th IEEE-CS Conference on Software Engineering Education and Training (CSEE T). 179–188. https://doi.org/10.1109/CSEET.2011.5876085Google ScholarDigital Library
- Yuanfang Cai, Rick Kazman, Ciera Jaspan, and Jonathan Aldrich. 2013. Introducing tool-supported architecture review into software design education. In 2013 26th International Conference on Software Engineering Education and Training (CSEET). 70–79. https://doi.org/10.1109/CSEET.2013.6595238Google ScholarCross Ref
- Marian Daun, Carolin Hübscher, and Thorsten Weyer. 2017. Controlled Experiments with Student Participants in Software Engineering: Preliminary Results from a Systematic Mapping Study. arxiv:1708.04662 [cs.SE]Google Scholar
- Pablo Anderson de L. Lima, Gustavo da C. C. Franco Fraga, Eudisley G. dos Anjos, and Danielle Rousy D. da Silva. 2015. Systematic Mapping Studies in Modularity in IT Courses. In Computational Science and Its Applications – ICCSA 2015, Osvaldo Gervasi, Beniamino Murgante, Sanjay Misra, Marina L. Gavrilova, Ana Maria Alves Coutinho Rocha, Carmelo Torre, David Taniar, and Bernady O. Apduhan (Eds.). Springer International Publishing, Cham, 132–146.Google Scholar
- Paul Denny, James Prather, Brett A. Becker, Catherine Mooney, John Homer, Zachary C Albrecht, and Garrett B. Powell. 2021. On Designing Programming Error Messages for Novices: Readability and Its Constituent Factors. Association for Computing Machinery, New York, NY, USA. https://doi.org/10.1145/3411764.3445696Google ScholarDigital Library
- Norman E Fenton and Shari L Pfleeger. 1998. Software Metrics: A Rigorous and Practical Approach. PWS Publishing Co., Boston, MA, USA. http://portal.acm.org/citation.cfm?id=580949Google ScholarDigital Library
- International Organization for Standardization. 2011. ISO/IEC 25010:2011: Systems and software engineering — Systems and software Quality Requirements and Evaluation (SQuaRE) — System and software quality models. https://www.iso.org/standard/35733.html.Google Scholar
- Lyndsey Franklin, Kristina Lerman, and Nathan Hodas. 2017. Will Break for Productivity: Generalized Symptoms of Cognitive Depletion. arXiv preprint arXiv:1706.01521(2017).Google Scholar
- Richard Gauthier and Stephen Pont. 1970. Designing Systems Programs. Prentice-Hall.Google Scholar
- Daniel Graziotin, Fabian Fagerholm, Xiaofeng Wang, and Pekka Abrahamsson. 2017. Unhappy developers: Bad for themselves, bad for process, and bad for software product. In 2017 IEEE/ACM 39th International Conference on Software Engineering Companion (ICSE-C). IEEE, 362–364.Google ScholarDigital Library
- Sandra G Hart. 2006. NASA-task load index (NASA-TLX); 20 years later. In Proceedings of the human factors and ergonomics society annual meeting, Vol. 50. Sage Publications Sage CA: Los Angeles, CA, 904–908.Google ScholarCross Ref
- Sandra G Hart and Lowell E Staveland. 1988. Development of NASA-TLX (Task Load Index): Results of Empirical and Theoretical Research. Human Mental Workload, Vol. 52. North-Holland, Amsterdam ;. 139–183 pages.Google Scholar
- Michael Kölling. 1999. The Problem of Teaching Object-Oriented Programming, Part I: Languages.JOOP 11 (04 1999), 8–15.Google Scholar
- M. Kolling. 1999. The problem of teaching object-oriented programming, Part 2: Environments. Journal of Object-Oriented Programming 11, 9 (1999), 6–12. http://bluej.kent.ac.uk/papers/1999-09-JOOP2-environments.pdfGoogle Scholar
- Joseph Lawrance, Christopher Bogart, Margaret Burnett, Rachel Bellamy, Kyle Rector, and Scott D Fleming. 2010. How programmers debug, revisited: An information foraging theory perspective. IEEE Transactions on Software Engineering 39, 2 (2010), 197–215.Google ScholarDigital Library
- Robert C. Martin. 1995. Object Oriented Design Quality Metrics: an analysis of dependencies. C++ Report (Sep/Oct 1995).Google Scholar
- Robert C. Martin. 2003. Agile Software Development: Principles, Patterns, and Practices. Prentice Hall.Google Scholar
- J. McCall, P. A. Richards, and Gene F. Walters. 1977. Factors in software quality: concept and definitions of software quality. Nat’l Tech. Information Service 1, 2, 3 (1977).Google Scholar
- Craig S. Miller and Amber Settle. 2016. Some Trouble with Transparency: An Analysis of Student Errors with Object-Oriented Python. In Proceedings of the 2016 ACM Conference on International Computing Education Research (Melbourne, VIC, Australia) (ICER ’16). Association for Computing Machinery, New York, NY, USA, 133–141. https://doi.org/10.1145/2960310.2960327Google ScholarDigital Library
- Nathan Mills, Allen Wang, and Nasser Giacaman. 2021. Visual Analogy for Understanding Polymorphism Types. In ACE ’21: 23rd Australasian Computing Education Conference, Auckland, New Zealand (and virtually), 2-5February, 2021, Claudia Szabo and Judy Sheard (Eds.). ACM, 48–57. https://doi.org/10.1145/3441636.3442304Google ScholarDigital Library
- Fred GWC Paas and Jeroen JG Van Merriënboer. 1994. Instructional control of cognitive load in the training of complex cognitive tasks. Educational psychology review 6, 4 (1994), 351–371.Google Scholar
- D. L. Parnas. 1972. On the criteria to be used in decomposing systems into modules. Commun. ACM 15, 12 (1972), 1053–1058. https://doi.org/10.1145/361598.361623Google ScholarDigital Library
- Chris Parnin. 2010. A cognitive neuroscience perspective on memory for programming tasks. Programming Interest Group(2010), 27.Google Scholar
- Chris Parnin and Spencer Rugaber. 2011. Resumption strategies for interrupted programming tasks. Software Quality Journal 19, 1 (2011), 5–34.Google ScholarDigital Library
- Shari L Pfleeger. 1998. Software Engineering: Theory and Practice. Prentice Hall.Google ScholarDigital Library
- Iflaah Salman, Ayse Tosun Misirli, and Natalia Juristo. 2015. Are Students Representatives of Professionals in Software Engineering Experiments?. In Proceedings of the 37th International Conference on Software Engineering - Volume 1(Florence, Italy) (ICSE ’15). IEEE Press, 666–676.Google ScholarCross Ref
- R. Shmallo and N. Ragonis. 2021. Understanding the “this” reference in object oriented programming: Misconceptions, conceptions, and teaching recommendations.Educ Inf Technol (2021). https://doi.org/10.1007/s10639-020-10265-6Google ScholarDigital Library
- Dag Ingar Kondrup Sjøberg, Jo Erskine Hannay, Ove Hansen, Vigdis By Kampenes, Amela Karahasanovic, Nils-Kristian Liborg, and Anette C. Rekdal. 2005. A Survey of Controlled Experiments in Software Engineering. IEEE Transactions on Software Engineering 31, 9 (September 2005), 733–753. https://doi.ieeecomputersociety.org/10.1109/TSE.2005.97Google Scholar
- D. I. K. Sjøberg, A. Yamashita, B. C. D. Anda, A. Mockus, and T. Dybå. 2013. Quantifying the Effect of Code Smells on Maintenance Effort. IEEE Transactions on Software Engineering 39, 8 (Aug. 2013), 1144–1156. https://doi.org/10.1109/TSE.2012.89Google ScholarDigital Library
Index Terms
- An Experiment on the Effects of Modularity on Code Modification and Understanding
Recommendations
Design module: a modularity vision beyond code: not only program code but also a design model is a module
MiSE '13: Proceedings of the 5th International Workshop on Modeling in Software EngineeringWe propose a new modularity vision to integrate design modeling with programming. A system consists of not only program code but also design models. However, design models such as UML diagrams have been treated as not modules but complementary ...
Automatic modularity conformance checking
ICSE '08: Proceedings of the 30th international conference on Software engineeringAccording to Parnas's information hiding principle and Baldwin and Clark's design rule theory, the key step to decomposing a system into modules is to determine the design rules (or in Parnas's terms, interfaces) that decouple otherwise coupled design ...
Assessing modularity using co-change clusters
MODULARITY '14: Proceedings of the 13th international conference on ModularityThe traditional modular structure defined by the package hierarchy suffers from the dominant decomposition problem and it is widely accepted that alternative forms of modularization are necessary to increase developer's productivity. In this paper, we ...
Comments