Towards game-based simulation as a method of teaching software engineering

The typical one-semester software engineering course is normally geared towards new software development. Unfortunately, most new computer science graduates do not find themselves in a position where they are developing new software but instead in a position where they are maintaining an existing product. This paper describes some current practical software maintenance approaches which can be taught as a part of a software engineering course.

The software engineering process is a growing concern for many software development organizations. The need for well-educated software engineers is bringing new software engineering programs to universities. In many programs, software process education adds up to a few hours of lectures in an introductory software engineering course. This paper presents the structure and the content for a full, one-semester course on software processes, which has been designed in close collaboration with industry. The course is based on a software process called UPEDU (Unified Process for EDUcation), pronounced Yoopeedoo, and has been customized from the Rational Unified Process (RUP) for the educational environment. Many artifacts derived from a project case study are used as examples or templates. The content of the course is oriented towards the cognitive skills needed to perform the various activities required in the software process.

Didactic experiences are very important in a Software Engineering course. We think they help to achieve at least six objectives of the course: to identify fundamental concepts of software engineering, to recognize software life cycles, models and methodologies of software development, to perform analysis of software products requirements, to design and develop a software product, to use the methodical processes of a real-world project, and to implement solutions following specific methodologies. In this paper we will show our didactic experiences in the Software Engineering Processes course. We developed a sequence of learning activities and their application (extracted from real requirements of clients and users) in different contexts such as environmental, medical and social, which results in higher levels of learning, interdisciplinary exercises and practices close to what students will face in their professional lives.

As software becomes more ubiquitous and complex, the cost of software bugs continues to grow at a staggering rate. To remedy this situation, there needs to be major improvement in the knowledge and application of software validation techniques. Although there are several software validation techniques, software testing continues to be one of the most widely used in industry. The high demand for software engineers in the next decade has resulted in more software engineering (SE) courses being offered in academic institutions. However, due to the number of topics to be covered in SE courses, little or no attention is given to software testing, resulting in students entering industry with little or no testing experience. We propose a minimally disruptive approach of integrating software testing into SE courses by providing students access to a collaborative learning environment containing learning materials on testing techniques and testing tools. In this article, we describe the learning environment and the studies conducted to measure the benefits accrued by students using the learning environment in the SE courses.

Software engineering has been taught over the years using expositive classes, but learning this discipline requires more than just theory. Lately, universities started teaching software engineering in a theoretical-practical way. Typically, these experiences involve the development of software projects in the academia, using industry-oriented or ad hoc processes. However, most of them are not fully formalized, therefore it is not possible to repeat, measure or improve them. Moreover, it is not clear which project contexts are proper for each ad hoc process. This thesis work proposes to define and formalize a prescriptive software development process for use in undergraduate software engineering courses. We hypothesize that this process can make these experiences repeatable investing an affordable effort and will help produce positive results in student projects. This software process will be evaluated in the context of a second software engineering undergraduate course at the University of Chile, and it will address specific project contexts. This software process could be used in any university that has a similar course context. The proposed process can also be adapted to fit with new contexts.

In software engineering education, large projects are widely recognized as a useful way of exposing students to the real-world difficulties of team software development. But large projects are difficult to put into practice. First, educators rarely have additional time to manage software projects. Second, classrooms have inherent limitations that threaten the realism of large projects. Third, quantitative evaluation of individuals who work in groups is notoriously difficult. As a result, many software engineering courses compromise the project experience by reducing the team sizes, project scope, and risk. In this paper, we present an approach to teaching a one-semester software engineering course in which 20 to 30 students work together to construct a moderately sized (15 KLOC) software system. The approach combines carefully coordinated lectures and homeworks, a hierarchical project management structure, modern communication technologies, and a web-based project tracking and individual assessment system. Our approach provides a more realistic project experience for the students, without incurring significant additional overhead for the instructor. We present our experiences using the approach the last 2 years for the software engineering course at The College of William and Mary. Although the approach has some weaknesses, we believe that they are strongly outweighed by the pedagogical benefits.

Software Engineering is important for the students majored in computer science and technology. This curriculum is intended to provide students with an overall view over Software Engineering as an engineering discipline and with insight into the processes of software development. Creating software Engineering curriculum faces several challenges: (1) Software Engineering has wide coverage, but teaching time is limited. So it is difficult to make in-depth education. (2) Some introductory Software Engineering courses present the principles in isolation from practice. Teaching the lectures seems to focus on philosophy and methodology level, which leads to difficulty for students having no practical experience to understand. (3) Due to the lack of software project practice, students can hardly apply appropriate software engineering methods and technologies to solve problems. (4) How can Software Engineering curriculum satisfy the various needs of different levels? This paper focuses on the challenges above, and introduces how to try to solve them by a case study on the construction of Software Engineering curriculum at Peking University. Finally, this paper gives the future direction for the construction of Software Engineering curriculum.

One of the main concerns in the software industry continues to be the development of high quality software. This concern will be exacerbated as software systems become more complex. The training of software developers continues to grow in academia since more institutions are offering software engineering (SE) courses. However, the list of topics that are expected to be covered in this course leaves little or no time for topics that focus on developing quality software, such as software testing and the use of testing tools.In this paper we describe an approach that non-intrusively integrates the use of software testing tools in SE courses. The cornerstone of our approach is the interaction students have with a Web-Based Repository of Software Testing Tools (WReSTT) that contains tutorials on testing concepts and testing tools. WReSTT employs both collaborative learning and social networking features that are attractive to students. We present the results of preliminary study performed in two SE courses that show how using the resources in WReSTT can potentially impact the students' understanding of software testing and the use of testing tools.

The goals of computer science department and software engineering courses are not always clear as they could be, and exactly how much of a computer science curriculum should be spent on software engineering topics at the expense of topics with more immediate relevance to computer science majors is far from clear. Computer science students are sometimes skeptical about the relevance of software engineering course topics, particularly those who have had some experience in industry. They report that the techniques and procedures covered in standard software engineering texts are seldom used in industry. There is not enough communication between Industry and Academia, and graduates often must be re-trained for their new jobs. This is a proposal for a modification in the approach to software engineering education for computer science majors, and for clarification of the goals of computer science programs, and calls for procedures to increase the relevancy of computer science and software engineering courses to meet the needs of industry.

The primary goal of an introductory software engineering course is to provide a complete introduction to software engineering. Typically this includes concepts, terms, processes, tools, and history. However, for students to fully understand software engineering and be prepared for software development careers, courses must also consider the sociological and communication aspects, often called the socio-technical aspects. Unfortunately, these aspects are difficult to teach and do not receive much coverage in the most widely used software engineering textbooks. Faculty have used various approaches to address the socio-technical aspects. One popular method is to use role-playing exercises. The software engineering education literature contains many papers advocating role-play. However, these papers describe role-play integrated in semester-long projects and often provide little detail about the exercises. Using these published approaches in an existing software engineering course requires significant work by the instructor. This paper presents a set of ready to use role-play exercises that can be downloaded and easily integrated into an existing course. Student reaction is also reported.

The evaluation of an advanced software engineering (SE) course is a challenging task that should be addressed as part of the course design. In this paper, we describe an implementation of the reflective practitioner perspective as part of an advanced SE course and introduce its use for feedback purposes. Reflective feedback goes beyond merely using feedback questionnaires. Furthermore, we show, using both qualitative and quantitative empirical data, that the course on which the perspective was applied meets its objectives and fosters students' awareness to the multidimensional nature of SE.

The Covid-19 pandemic forced many academic institutions around the world to switch to online teaching. This shift occurred suddenly and with little preparation and this method of instruction was named “emergency remote teaching”. This paper will describe the effects of emergency remote teaching on teaching a software engineering course at a Japanese university, showing how the online environment was used as an alternative to cancelling classes. Strategies for implementing active learning and for engaging students during this software engineering course will be highlighted. Based on the results and observations gathered during the teaching of this course, important conclusions will be drawn. They will constitute a starting point for planning and implementing future software engineering courses and for making sure that active learning continues to remain an essential part of the instruction process.KeywordsEmergency remote teachingActive learningSoftware engineering

Over time much has been written on how to organize a course on software engineering, with arguments flowing for and against additional complexity. It is highly believe that SWE is an umbrella course in computing and most dangerously in any course proclaimed to be specialist in generating Software Engineers. Unfortunately, this may still not be widely recognized, both in the industry and in academia. The modern course on SWE requires that the student is familiar not just with many aspects of computing such as programming languages but rather with many other aspects including networking, Internet technologies, programming languages, databases, Human Computer Interaction (HCI), computer graphics, and project management. Depending on the year of academic study these expectations could be unrealistic, especially if that is a 2nd year course. Based on the above view, it is essential to investigate what are the necessary attributes of an ideal Software Engineering at the undergraduate level and how much it is covering of the requirements imposed by the business and industry market. This paper will investigate how appropriate are Software Engineering courses at the undergraduate level in terms of the areas of concentration, delivery approach, and the real life practical training received by the target group of students. It will deeply investigate the overall intended learning objectives and how they are related to the choice of modules offered. On the other hand, a number of business institutions will be surveyed for achieving an overview of how effective graduates of Software engineering courses are within these selected institutions and most importantly what are the challenges they encounter in professional life given their level of university education i.e. how helpful their undergraduate education has been helpful to their development as specialists.

Software Engineering courses are perceived as being dry and boring. The education community has been looking at active learning and hands-on training techniques to engage students better and thereby provide a better understanding of concepts. This paper presents a web-based game called Scrumify, developed by undergraduate students, that is designed to introduce students to the Scrum software development process through story elements, and quiz mechanics. The game is designed to reinforce software engineering concepts more specifically agile software processes. Quizzes within the game are designed to grant points that inject a sense of competition for the users and motivation to learn the agile methodology concepts. Scrumify serves two objectives: software engineering education for audience of the game and web-based game development and software testing education for the developers of the game. Use of this game in classroom provides an active learning technique for agile software processes. Students are more engaged with games and thereby absorb the concepts better. The game was evaluated in a sophomore software engineering class and the results are presented.

Much of our recent work has been predicated on the hypothesis that extensive use of typing will be an important aspect of creating and using process models. In particular, we have been actively investigating type models specifically tailored for use in software environment and process model definition. We recently used class projects in two different software engineering courses as preliminary experiments on the efficacy of typing in creating process models. In this paper we sketch our type model work, describe the experiments and offer a brief assessment of the results.