An experimental card game for teaching software engineering processes
Introduction
It is now well known that software engineering professionals working in industry are generally unsatisfied with the level of real-world preparedness possessed by recent university graduates entering the workforce (Callahan and Pedigo, 2002; Conn, 2002; McMillan and Rajaprabhakaran, 1999; Wohlin and Regnell, 1999). Their frustration is understandable – in order for these graduates to be productive in an industrial setting, organizations that hire them must supplement their university education with extensive on-the-job training and preparation that provides them with the skills and knowledge they lack (Conn, 2002). The root of the problem seems to lie in the way software engineering is typically taught: theories and concepts are presented in a series of lectures, and students are required to complete a small, toy project in an attempt to put this newfound knowledge into practice. Although both of these components are necessary and useful parts of educating future software engineers, they lack an adequate treatment of many of the critical issues involved in the overall process of software engineering. Specifically, the time and scope constraints inherent in an academic setting prohibit the project from being of a sufficient size to exhibit most of the phenomena present in real-world software engineering processes––those that involve large, complex systems, large teams of people, and other factors such as management, workplace issues, and corporate culture. Although the instructor can explain most of these issues in lectures, students do not have an opportunity to participate in an entire, realistic software engineering process firsthand.
In recent years, software engineering academics have put much effort into mitigating this problem by devising new ways of teaching software engineering: requiring students to work on projects sponsored by an external organization (Hayes, 2002; Mayr, 1997), intentionally applying real-world complications during the class project, such as changing requirements while the design is in progress (Dawson, 2000), incorporating multiple universities and disciplines into the project (Burnell et al., 2002), maintaining a large-scale, ongoing project that different groups of students work on from semester to semester (Sebern, 2002), and many others. All of these approaches share the same goal: to bridge the disconnect between theory and practice. While certainly an improvement over traditional class projects, the constraints imposed by the academic environment (namely, limited time and a dominating focus on deliverables rather than on the process used to create them) still apply and prevent many of the issues present in real-world software engineering processes from being experienced (although each approach does succeed in highlighting a few of these issues).
To address this problem, we have developed a unique approach to teaching the software engineering process: Problems and Programmers, an educational card game that simulates the software engineering process from requirements specification to product delivery. Problems and Programmers provides students with an overall, high-level, practical experience of the software engineering process in a rapid enough manner to be used repeatedly in a limited amount of time (i.e., a quarter or semester). Furthermore, it takes the focus off of actual deliverable artifacts and highlights the overall process by which they are developed.
Aside from these, Problems and Programmers has a number of other qualities that contribute to its learning effectiveness. First, it is competitive: each player takes on the role of project manager, and must complete the project before any of the opponents do. Not only does competition motivate students to play the game, but it also encourages collaborative learning, an educational technique that is know to have significant advantages (Bruffee, 1983). Second, the game is physical, meaning it is played using actual cards and with face-to-face interaction between players. This physical nature further encourages collaborative learning and also ensures that all of the underlying mechanics of the software engineering process being simulated are visible (and therefore more learnable). Lastly, Problems and Programmers has a fun and engaging nature, a quality that is known to be highly conducive to learning (Ferrari et al., 1999). Entertaining character descriptions, humorous character illustrations, and unexpected situations further add to this quality.
It is our intention that one or two class periods in a course would be dedicated to learning and playing the game as a way to supplement the material already learned. Surely, lectures are still needed to teach the fundamental concepts and theories of software engineering, and projects still provide students with useful experience in creating deliverables, but the addition of this game could enrich the curriculum. As an initial evaluation of the game's feasibility and worth as a complementary teaching tool, we recruited a group of students who had passed an introductory software engineering course to play the game, and collected their feedback.
The remainder of this paper is organized as follows: Section 2 outlines the overall objectives of Problems and Programmers, both as a game and as an educational tool. Section 3 details the design and mechanics of the game. Section 4 briefly describes the experiment we performed to evaluate the effectiveness of the game, as well as lessons learned from it. Section 5 provides an overview of existing research related to our work, and we end in Section 6 with our conclusions and directions for future work.
Section snippets
Objectives
Problems and Programmers is a teaching tool, and as such its purpose is to educate. One possible approach to teaching virtually any subject is to create a simulation. In the case of Problems and Programmers, the game should simulate the software engineering process, as this is the particular subject that we aim to teach.
In general, each event in the game needs to be associated with a corresponding event in the real world. Accomplishing this goal has a twofold benefit. First, the connections
Overall design
The game is organized as a competitive game, in which students take on the roles of project leaders in the same company. They are both given the same project and are instructed to complete it as quickly as possible. The player who completes the project first will be the winner. However, players must balance several competing concerns as they work, including their budget and the client's demands regarding the reliability of the produced software. In essence, they must strive to follow proper
Experiment design
In order to perform an initial evaluation of the game, we designed a simple experiment in which students were taught to play the game and then asked to submit written feedback in the form of answers to structured questions. While more subjective than some other evaluation methods, we feel that this was well suited to an initial evaluation of the concept, and allowed us flexibility in the information that we gathered. In the future, we plan to utilize more formal approaches – namely, performing
Related work
This research draws from three main areas of related work: simulation in education, software engineering education, and software process simulation. The following subsections describe the relationships between Problems and Programmers and these existing bodies of work.
Conclusions and future work
Problems and Programmers represents a first attempt at using a physical card game to teach students about the software engineering process. It addresses many of the weaknesses of more traditional techniques and brings additional benefits in the form of face-to-face learning and enjoyable play. We believe that when used in conjunction with lectures and projects, Problems and Programmers will allow students to gain a thorough understanding of real-world lessons that might otherwise have been
Availability
More information about Problems and Programmers, as well as a freely downloadable version of the cards, is available at: http://www.problemsandprogrammers.com.
Acknowledgements
We thank the other members of our research group for their invaluable suggestions regarding the design and implementation of Problems and Programmers.
Effort funded by the National Science Foundation under grant numbers CCR-0093489 and IIS-0205724. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of the National Science Foundation.
Alex Baker is currently working towards a Ph.D. in Information and Computer Science at the University of California, Irvine. He received his B.S. in Information and Computer Science from the University of California, Irvine in 2002. He is the primary designer of Problems and Programmers, and continues to develop card and board games for teaching software engineering. His research interests include software design techniques, software engineering education and application of games to software
References (31)
Eliciting self-explanations improves understanding
Cognitive Science
(1994)- et al.
Software process simulation to achieve higher CMM levels
The Journal of Systems and Software
(1999) - et al.
Sofftware Project Dynamics: an Integrated Approach
(1991) Cognitive tutors: lessons learned
The Journal of the Learning Sciences
(1995)The Mythical Man-Month: Essays on Software Engineering
(1995)Collaborative Learning: Higher Education, Interdependence, and the Authority of Knowledge
(1983)- et al.
Teaching distributed multidisciplinary software development
IEEE Software
(2002) - et al.
Educating experienced IT professionals by addressing industry's needs
IEEE Software
(2002) - Collofello, J.S., 2000. University/Industry collaboration in developing a simulation based software project management...
Developing software engineers at the C-130J software factory
IEEE Software
(2002)
Discovering process models of software processes from event-based data
ACM Transactions on Software Engineering and Methodology
201 Principles of Software Development
Adapting work simulations for schools
The Journal of Educational Computing Research
Cited by (164)
Impacts of a flipped classroom with a smart learning diagnosis system on students’ learning performance, perception, and problem solving ability in a software engineering course
2019, Computers in Human BehaviorCitation Excerpt :Many studies have proposed various approaches to conducting a learner-centered learning environment in different courses (Jou, Lin, & Tsai, 2016; Kong, 2015; Lin, 2016; Lin, Wen, Jou, & Wu, 2014). However, since the course duration is limited by the semester, most teachers can only conduct a teacher-centered learning environment to teach theoretical concepts to students (Baker, Navarro, & van der Hoek, 2005). In the teacher-centered learning environment, the teacher transmits knowledge to students directly, and the students are the recipients.
Extending Educational Games Across Product Lines
2024, Communications in Computer and Information ScienceA Conceptual Model to Support Teaching of Software Engineering Controlled (Quasi-)Experiments
2023, ACM International Conference Proceeding SeriesSoftware Engineering Education Through Experiential Learning for Fostering Soft Skills
2023, Proceedings - Frontiers in Education Conference, FIEA Serious Game with Which to Introduce Users to the World of DevOps
2023, International Conference on Computer Supported Education, CSEDU - ProceedingsA Scoping Review of the Metaverse for Software Engineering Education: Overview, Challenges, and Opportunities
2022, Presence: Teleoperators and Virtual Environments
Alex Baker is currently working towards a Ph.D. in Information and Computer Science at the University of California, Irvine. He received his B.S. in Information and Computer Science from the University of California, Irvine in 2002. He is the primary designer of Problems and Programmers, and continues to develop card and board games for teaching software engineering. His research interests include software design techniques, software engineering education and application of games to software engineering.
Emily Oh Navarro received her B.S. in Biological Sciences and her M.S. in Information and Computer Science from the University of California, Irvine in 1998 and 2003, respectively. She is currently pursuing a Ph.D. in computer science at the University of California, Irvine, focusing on developing game-based simulation tools for software engineering education. She is the lead developer on the SimSE project and has also contributed to the design and evaluation of Problems and Programmers. She has been a GAANN fellowship recipient for the past 2 years and is also an ARCS scholar.
Andrvan der Hoek André van der Hoek is an assistant professor in the Informatics Department of the School of Information and Computer Science, and a faculty member of the Institute for Software Research, both at the University of California, Irvine. He holds a joint B.S. and M.S. degree in Business-Oriented Computer Science from the Erasmus University Rotterdam, the Netherlands and a Ph.D. degree in Computer Science from the University of Colorado at Boulder. His research interests include configuration management, software architecture, product line architectures, configurable distributed systems, and software engineering education. He has developed several CM systems (including NUCM, SRM, Palantı́r,TWICS, and MCCM), was chair of SCM-10, and is co-author of the Configuration Management Impact report. He is on the program committee for ICSE 2004, ICSE 2005, and FSE-12, and has contributed to the development of Problems and Programmers.