An experimental card game for teaching software engineering processes

https://doi.org/10.1016/j.jss.2004.02.033Get rights and content

Abstract

The typical software engineering course consists of lectures in which concepts and theories are conveyed, along with a small “toy” software engineering project which attempts to give students the opportunity to put this knowledge into practice. Although both of these components are essential, neither one provides students with adequate practical knowledge regarding the process of software engineering. Namely, lectures allow only passive learning and projects are so constrained by the time and scope requirements of the academic environment that they cannot be large enough to exhibit many of the phenomena occurring in real-world software engineering processes. To address this problem, we have developed Problems and Programmers, an educational card game that simulates the software engineering process and is designed to teach those process issues that are not sufficiently highlighted by lectures and projects. We describe how the game is designed, the mechanics of its game play, and the results of an experiment we conducted involving students playing the game.

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)

  • M.T.H. Chi

    Eliciting self-explanations improves understanding

    Cognitive Science

    (1994)
  • D. Raffo et al.

    Software process simulation to achieve higher CMM levels

    The Journal of Systems and Software

    (1999)
  • T. Abdel-Hamid et al.

    Sofftware Project Dynamics: an Integrated Approach

    (1991)
  • J.R. Anderson

    Cognitive tutors: lessons learned

    The Journal of the Learning Sciences

    (1995)
  • F.P. Brooks

    The Mythical Man-Month: Essays on Software Engineering

    (1995)
  • K.A. Bruffee

    Collaborative Learning: Higher Education, Interdependence, and the Authority of Knowledge

    (1983)
  • L.J. Burnell et al.

    Teaching distributed multidisciplinary software development

    IEEE Software

    (2002)
  • D. Callahan 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...
  • R. Conn

    Developing software engineers at the C-130J software factory

    IEEE Software

    (2002)
  • J.E. Cook et al.

    Discovering process models of software processes from event-based data

    ACM Transactions on Software Engineering and Methodology

    (1998)
  • A.M. Davis

    201 Principles of Software Development

    (1995)
  • Dawson, R., 2000. Twenty dirty tricks to train software engineers, in: Proceedings of the 22nd International Conference...
  • Drappa, A., Ludewig, J., 2000. Simulation in software engineering training. In: Proceedings of the 22nd International...
  • M. Ferrari et al.

    Adapting work simulations for schools

    The Journal of Educational Computing Research

    (1999)
  • 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 Behavior
      Citation 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 Science
    • Software Engineering Education Through Experiential Learning for Fostering Soft Skills

      2023, Proceedings - Frontiers in Education Conference, FIE
    • A Serious Game with Which to Introduce Users to the World of DevOps

      2023, International Conference on Computer Supported Education, CSEDU - Proceedings
    View all citing articles on Scopus

    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.

    Andrévan 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.

    View full text