Collaborative learning in groups has practical and pedagogical benefits. In software engineering education, the group formation stage can have an important influence on the quality of learning and students' satisfaction with their group. Knowledge of student experiences and preferences regarding group formation can inform course design and hopefully lead to better learning outcomes and student satisfaction. In this paper, we report experiences of group formation in software engineering courses, focusing on students' perspectives. We used surveys administered on three master's level software engineering courses, through which we explored students' prior experiences with group work in educational settings and their perspectives on how groups should be formed. We present results on students' thoughts about who should form groups, what information criteria they would consider as relevant when forming groups, and what kind of group formation strategy they prefer. Our results indicate that students preferred to keep the group formation process in their own hands, that they considered grade ambitions, educational background, and time availability to be important factors to consider, and that they generally preferred the formation strategy already used on the courses they attended. We also discuss how students' prior experiences may have coloured their perceptions of group formation strategies and the ethical dilemmas facing instructors when choosing different strategies. We present points of consideration for teachers who are interested in improving group formation on their software engineering courses.
The software engineering graduate apprenticeship program at the School of Computing, University of Glasgow, has a significant emphasis on work-based learning (WBL), with approximately 80% of the students' time over four years spent in the workplace. This work-based aspect of the program plays a more prominent role in the final two years, by which time apprentices are undertaking increasingly larger roles in the workplace. In this report, we present how we addressed the challenge of structuring and assessing WBL in these senior years such that there is a balance between professional competency attainment and ranked academic achievement, while providing a fair and flexible structure. Based on a model of WBL presented by Raelin in 1997, we outline our rationale for dividing the assessments into workplace projects, workplace journal, and a portfolio of artefacts. The projects are categorised into different types both for flexibility and to encourage academia-industry collaboration, the workplace journal encourages higher forms of reflection, while the portfolio assessment encourages and assesses the attainment of professional competencies. We present our experience of implementing this structure, an analysis of student feedback, and the adjustments made in response. With an increasing focus on work-ready skills and competency-based education in software engineering education, we expect the theory-informed structure we developed, and our experience of running and adapting it, to serve as an exemplar for developing a WBL program at research-led institutions.
Kubernetes has become a popular tool for automated container orchestration. Despite reported benefits, practitioners report that the secure configuration of Kubernetes is one of the primary challenges among practitioners. Moreover, there is a significant skill shortage of Kubernetes security experts. Understanding misconfigurations in Kubernetes can help practitioners prevent security incidents. We systematically investigate whether authentic learning can help students learn about misconfigurations in Kubernetes. We conduct an authentic learning exercise and collected responses from 295 students. Based on responses from the students, we find (i) students who have little to no experience in cybersecurity, software quality assurance, or static analysis perceived the authentic learning exercise as useful to learn misconfigurations in Kubernetes, and (ii) students perceptions of authentic learning exercise activities vary based on and educational background. We conclude our paper with recommendations for instructors and researchers.
As software becomes increasingly important, so does the education of people who develop software. To provide a good and motivating education to learners, it is necessary to be aware of their preferences. To give insight into the preference of learners, we conducted a study with university students and professionals aimed at learning more about their preferences. Results from our survey- and focus group-based research show large similarities between both groups of learners, such as the preference for e-learning materials, as this provides them flexibility for scheduling their learning sessions. However, differences exist when it comes to the preferred scheduling of online and offline sessions. Our findings can help educators not only in designing courses for university students or professionals, but also in designing courses that can be used by both groups of learners.
Programming knowledge is a crucial aspect of computer science education, and unit testing is commonly employed to automatically assess programming assignments. Instructors and teaching assistants typically invest considerable efforts in writing unit tests, which may still be vulnerable to human oversight and mistakes. In this work, we explored the feasibility of using Large Language Models (LLMs) to automate the assessment of programming assignments. In particular, we proposed two approaches: the plain approach that uses GPT-4o-mini in a vanilla setting, and the augmented approach that integrates additional strategies such as tailored prompts with syntax and semantic constraints, and a feedback mechanism with information on test-effectiveness metrics. We evaluate the two approaches on six real-world programming assignments from an introductory-level programming course at our university. Compared to the plain approach, the augmented approach improves the usability and effectiveness of the generated unit tests, reducing 85 % compilation errors while enhancing the statement coverage and mutation scores by 1.7 x and 2.1 x, respectively. In addition, the augmented approach also complements human-written tests by covering additional program behaviors. In a case study of 1296 students' submissions that pass human-written tests, the augmented approach successfully detected new bugs in 13 % submissions, with an accuracy of 27 %. These results not only demonstrate the potentials of LLMs in generating useful unit tests for programming assignments, but also highlight the strategies that can effectively enhance LLMs' capabilities to augment human-written tests, offering practical benefits for both educators and students.
A cross-sectional, questionnaire-based survey of software testing courses offered at Swedish universities was undertaken in the final quarter of 2023. With a return rate of 44%, the survey delved into the contents of these software testing courses to gain an understanding of how the courses differ in terms of depth and breadth of content. Information was also sought about administrative and course planning activities related to the courses. Some key findings are that there is in-depth coverage of unit testing in all the courses, with none of the courses offering in-depth testing of other test levels such as acceptance testing. Also notable is the difference in test types. As an example, functional testing is taught in-depth in all the courses, while accessibility testing is not taught at all in half of the courses. It is suggested that a greater range of software testing topics is needed in future education if more stakeholders, such as business analysts and software developers, not just software testers, are to have a quality-centred approach to software development.
Software engineering is no longer only an important subject in the education of computer science degree programs to train traditional software engineers, but made its way into a number of technical engineering degrees. Software engineering education, there, takes a vital part in preparing future engineers in developing highly specialized software in various domains. One example is robotics, we currently see a rise in industry's need for well-educated roboticists, which is reflected in an increasing number of robotics degree programs. In these programs, students are trained to develop individual software-based applications for standardized robotics hardware. In addition, students need to be able to blend into bigger software engineering programs considering IoT applications. Therefore, software engineering is an important part of students' education. However, due to other important fields to be taught during their studies (e.g., electrical engineering, mechanical engineering), it is impossible to teach all software engineering related aspects as is part of a software engineering. In addition, students are missing basic knowledge from lower semester computer science subjects, which are not part of these technical degree programs as well. Therefore, there is a need to define a software engineering curriculum for these technical engineering degree programs that provides students with sufficient software engineering knowledge and skills.
Software engineering education has been predominantly focused on educating software engineering and computer science students. However, software engineering has increasingly spread into other disciplines, such as robotics. However, in addition to computer science, robotics programs are based on a number of other disciplines, including electrical and mechanical engineering. This not only limits the time and courses available for software engineering education but also requires educational approaches to address a student body with distinct skill sets and problem-solving methods. In addition, robotics students are faced with complex software engineering problems, as robotics systems become more complex and integrate with other systems, such as Cyber-Physical Systems and the Internet of Things. The integration of services and the collaboration between different systems require advanced software engineering skills and the ability to work on complex business logics connecting multiple systems. This paper reports on our experiences of teaching software engineering to robotics students. We report of two installments of a software engineering course in a robotics degree program. After the first installment, we changed the course schedule to better reflect robotics students' needs and to place more emphasis on the specific characteristics of software engineering and the related skills that differ from other technical engineering subjects. Consequently, we share our insights from the initial implementation of the course and offer comprehensive insights for enhancing future iterations.
A few years after their release, Large Language Models (LLMs)-based tools are becoming an essential component of software education, as calculators are used in math courses. When learning software engineering (SE), the challenge is the extent to which LLMs are suitable and easy to use for different software development tasks. In this paper, we report the findings and lessons learned from using LLM-based tools-ChatGPT in particular-in five SE courses from four universities. After instructing students on the LLM potentials in SE and about prompting strategies, we ask participants to complete a survey and be involved in semi-structured interviews. The collected results report (i) indications about the usefulness of the LLM for different tasks, (ii) challenges to prompt the LLM, i.e., interact with it, (iii) challenges to adapt the generated artifacts to their own needs, and (iv) wishes about some valuable features students would like to see in LLM-based tools. Although results vary among different courses, also because of students' seniority and course goals, the perceived usefulness is greater for lowlevel phases (e.g., coding or debugging/fault localization) than for analysis and design phases. Interaction and code adaptation challenges vary among tasks and are mostly related to the need for task-specific prompts, as well as better specification of the development context.
Background: When acquiring new programming languages, learners typically transfer their knowledge from previous languages to the new one. Recent studies demonstrate that this transfer is similar to the process of learning a second language, so learning can be more efficient, but also interference can take place, similar to false friends. While these studies demonstrate the existence of transfer, they have focused on programming languages with rather larger differences, such as Python versus Java. Objective: Our goal is to understand how students transfer between two similar programming languages, that is, from C to Java, adding a different angle to how transfer takes place. Method and Results: To this end, we gave students a Java comprehension test in the first week of a CS2 course, after they have completed a CS1 course based on C. We could confirm that students transfer knowledge from C to Java, including false friends. We repeated this study a year later, but included a dedicated Java tutorial before conducting the Java comprehension test. With these explicit instructions, students experienced less interference when learning Java, demonstrating that they profit from being made explicitly aware of the syntactical intricacies of Java. However, we also observed persistent interference for some concepts, indicating the need for more in-depth instructions.
Although high-quality software is key for a safe society, beginners still struggle to understand programming basics, whereas experienced programmers consider testing code as an unnecessary, boring chore. The situation will improve when, instead of asking students to write hypothetical code or test cases, one challenges them to find and fix bugs deliberately injected in real, executable code. Since 2020, we have been developing educational artifacts needed to test this radically new hypothesis, including a web-based bug-hunting game for standalone code, and small-scale cyber-physical systems (a self-driving car and a smart home), controlled by fault-seeded embedded software. We deployed the proposed approach and artifacts in the following settings: a software testing course for 300 computer science students, an exam for 250 economics students enrolled in an introductory Python course, and a software testing refresher workshop for 80 alumni of an IT retraining programme. Evaluations based on surveys with Likert-scale and open questions showed that a fault-based, active-learning approach (1) increases excitement in learning and (2) offers a more adequate way to assess students' skills, compared to the traditional pen-and-paper or MC exams. Future work includes equalizing the difficulty level of injected bugs and adding other gaming elements, such as badges, scoreboards, automated grading and adaptive feedback. While we realize that more rigorous qualitative and quantitative evaluations will be needed to confirm the generalizability of our approach, we are confident in its potential to contribute to making future professionals better prepared to engineer the high-quality, safe software we all can rely on.
Teamwork is beneficial for students' learning experiences. However, inherent challenges persist, including free-riding, conflicts, and communication issues. To tackle these issues, the use of peer assessment has been widely advocated, and practiced. For various reasons, however, peer assessment tends to be performed infrequently, limiting its utility for instructors to detect issues in, and intervene with, student teams during a course. One reason is that existing tools do not present peer assessment results over time, not for individual team members, nor for teams as a whole. In this experience report, we introduce a new dashboard that is specifically designed to address time, and report and reflect on the experiences of three instructors who used the dashboard to monitor teams in their courses and intervene when they thought it was necessary.
Pull requests allow developers to suggest and review codebase changes collaboratively. This process is standard for maintaining code quality and following best practices. The recent emergence of Large Language Models like ChatGPT and GitHub Copilot has shown great potential in improving coding efficiency and accuracy in software engineering. This paper outlines a study design to explore the integration of an AI tool to streamline PR reviews in a software engineering course. By incorporating the pr-agent into the curriculum, the study aims to evaluate its impact on students' coding skills, understanding of PR processes, and overall learning experience. The evaluation strategy includes collecting quantitative and qualitative feedback from students to assess the effectiveness of the tool. The results will offer insight into the feasibility and benefits of integrating AI tools in software engineering education.
Considering that every company is becoming a software company, there will be an ongoing demand for qualified software engineers. However, there seems to be a supply shortage of graduates in Computer Science or Software Engineering from the traditional university education. It has been observed for decades that a considerable number of developers in the software industry do not have computer science degrees and basic software engineering educations. On the other hand, such a phenomenon may have revealed the reality and trend that the software industry will continue the intake of career-shift employees and graduates from non-computer science disciplines. Therefore, we argue software engineering conversion programmes to be a strategic and long-term approach to fostering qualified software engineers. The conversion programmes will substantially supplement the classic university programmes and address the disadvantage of unconventional entry points (e.g., bootcamp training and selflearning). We have conducted critical reflection on our first-hand educational practice together with extensive literature review to justify our argument.
Plagiarism is a significant challenge in computer science education. Thus, tool-based approaches are widely used to combat software plagiarism. However, especially due to the recent rise of automated obfuscation via algorithmic or AIbased techniques, these tools face difficulties due to increasingly sophisticated obfuscation techniques. To address this challenge, we present a novel defense mechanism against automated obfuscation attacks. This mechanism iteratively merges matching program subsequences to counteract the effects of the obfuscation. Our approach is language-independent, attack-agnostic, and integrates well into state-of-the-art software plagiarism detectors. The evaluation based on five real-world datasets indicates that our approach not only provides broader resilience against algorithmic and AI-based obfuscation attacks than the state-of-the-art but also improves the detection of fully AI-generated programs.
Team projects are an essential part of any software engineering program, and are known to help students in learning the primary course materials while imparting valuable teamwork skills. At the same time, teamwork can also present challenges, to both students and their instructors. Well-known problems include teams not following recommended practices (e.g., producing deliverables out of order or at the last minute) and problematic team dynamics interfering with progress (e.g., social loafing or last-minute heroes). This paper presents TeamCAST, a tool we designed to address both kinsd of problems. The key idea underneath TeamCAST is that, by tapping into the intermediate work that students produce as part of their projects, it becomes possible to gain insight into both team progress and contributions. TeamCAST is designed to provide an easy-to-use platform for students to submit such intermediate work and for instructors to monitor the ongoing projects in an intuitive dashboard. This experience report introduces the primary design decisions underlying TeamCAST and presents the results of an exploratory pilot use in a 179 student software design class.
Empathy, i.e., the ability to understand and feel what others are going through, is essential for value-based and user-centered software development. Empathy helps software engineers fully understand client needs, but also impacts how software engineers work with each other (e.g., within their team). However, junior and less experienced software engineers may not always understand what empathy means and why it matters in a technical domain like software development (and therefore do not pursue opportunities to develop it). We present a video-based training technique for empathy of software engineers. We also show preliminary findings of using the technique in a software engineering project course for second-year software engineering students. We report on student learning, engagement, as well as the perceptions of students on the training technique.
Teaching Requirements Engineering (RE) is challenging, as it involves dealing with the complexity and abstraction of technical and business problems. Students need to learn how to properly identify requirements, document them, validate them, and communicate with various stakeholders, such as clients and technical teams, to understand what needs to be done. Traditional teaching methods often fail to engage students, making bridging theoretical concepts with practical applications difficult. This paper presents the Game Design Storytelling (GDS) process as a framework to gamify educational experiences in RE. GDS integrates narrative-based game elements with learning objectives, offering a structured approach to create interactive and engaging lessons. We applied GDS in an RE class focused on creating user stories using a dystopian narrative set in a fictional world called “Cyberium.” Students were challenged to solve complex problems by developing user stories within this immersive environment. The results indicate that the gamified lesson increased student engagement and facilitated the understanding of technical concepts. The professor reported greater student interest in completing the gamified activity, and the feedback from students was positive, with some stating it was the “best class” they had in their undergraduate program, highlighting the relevance of narrative and interactivity for learning.
Software testing plays a critical role in the success of software development projects. As the complexity of software grows, the demand for qualified software testing specialists is rising. Despite this, a gap persists between the knowledge required in the industry and the competencies offered in academic curricula. To delve deeper into educational strategies, this study investigates the state of software testing education in German higher education by analyzing module manuals from 162 Universities and Universities of Applied Sciences manually, focusing on Information Systems, Computer Science, and Information and Media Technology-related study programs. We assess in 754 study programs the integration of teaching methods and competencies of 1.552 modules related to software testing. The research identifies variations in educational approaches and gaps between the instructional content and industry standards, e.g., the ISTQB Foundation Level. The findings emphasize the importance of aligning software testing education with industry standards and suggest incorporating practical, project-based learning to better prepare students for the professional demands of software testing. Therefore, based on teaching approaches from the module manuals, we provide recommendations to enhance the integration of software testing in curricula, focusing on the broader inclusion of ISTQB standards, practical exercises, and interdisciplinary teaching approaches. This study contributes to the ongoing discourse on improving software testing education and highlights areas for future research in academic and practical contexts.
The Software Engineering (SE) workforce is still man-dominated, and there are still fewer women students graduating from Computer Science/Software Engineering (CS/SE) courses in most countries. Two major reasons are fewer women enrolling in CS/SE courses and a lower percentage of those women who enrolled completing courses. We wanted to investigate the second reason - the experiences of students within the CS/SE education environment to identify key issues that need improvement to increase women student recruitment and completion. We interviewed 18 CS / SE students to explore their experiences. We requested they review selected SE education content to understand the perception of gender diversity within the SE education environment. Our findings indicate that many women students feel excluded by several behavioural aspects of their fellow men students, as well as by some teachers. We found that gender-biased language and stereotypical images make women students feel more excluded. From the experiences and opinions of our participants, we propose recommendations for higher education CS/SE teachers, universities and researchers to improve gender inclusion in SE teaching environments.
