Game-based learning (GBL) has emerged as a powerful instrument for enhancing student engagement and motivation in education. This paper evaluates the impact of Gamify-IT, an educational game designed for programming education, on student motivation and learning experiences. Building on the original Gamify-IT concept, we extended it with novel features, including diverse minigames, leaderboards, and a redesigned achievement system, to align with Marczewski's HEXAD player types. The platform was used in a first-semester programming course by about 100 students, and its impact was evaluated through comparative analyses of two cohorts in consecutive CS1 programming courses: one limited to traditional teaching methods and the other incorporating Gamify-IT. Our results demonstrate that Gamify-IT has a positive impact on student motivation, as evidenced by higher initial and sustained motivation levels throughout the semester. Feedback from a survey regarding the usefulness and experiences of the platform highlights its strengths, including an engaging and innovative learning approach, game design, and visuals, while also identifying areas for improvement, such as addressing technical issues and expanding game variety. Despite these challenges, Gamify-IT demonstrates the potential of GBL in programming education, offering valuable insights for designing inclusive and effective gamified educational tools for programming education.

Automated GUI testing is crucial in ensuring that presentation logic behaves as expected. However, existing tools often apply end-to-end approaches and face challenges such as high specification efforts, maintenance difficulties, and flaky tests while coupling to GUI framework specifics. To address these challenges, we introduce the ViMoTest tool, which leverages Behavior-driven Development, the ViewModel architectural pattern, and projectional Domain-specific Languages (DSLs) to isolate and test presentation logic independently of GUI frameworks. We demonstrate the tool with a small JavaFX-based task manager example and generate executable code.

ABSTRACT Domain The deployment of distributed multi‐component cloud applications typically requires a combination of multiple heterogeneous deployment technologies. A different combination of deployment technologies should be chosen due to varying deployment qualities, such as the functional suitability and reliability of the deployment technologies for the deployment of the components. A suboptimal selection of deployment technologies makes the deployment error‐prone. Problem Selecting and maintaining the combination of deployment technologies requires modeling effort and expertise. Contributions We present a method that automatically selects deployment technologies based on a knowledge base of deployment scenarios and corresponding deployment qualities of deployment technologies. Evaluation We show the practical applicability and the usefulness of our method. For the practical applicability, we conduct two case studies based on an open‐source reference architecture application and a real‐world industry application using a prototypical implementation of our method. For the usefulness, we conduct a user study in which participants assign deployment technologies with and without our method. Conclusions Our method is a useful contribution that reduces the modeling effort and the required expertise when maintaining the combination of deployment technologies. Further, our method enhances the deployment quality.

Lecturers are increasingly attempting to use large language models (LLMs) to simplify and make the creation of exercises for students more efficient. Efforts are also being made to automate the exercise creation process in software engineering (SE) education. This study explores the use of advanced LLMs, including GPT-4 and LaMDA, for automated programming exercise creation in higher education and compares the results with related work using GPT-3.5-turbo. Utilizing applications such as ChatGPT, Bing AI Chat, and Google Bard, we identify LLMs capable of initiating different exercise designs. However, manual refinement is crucial for accuracy. Common error patterns across LLMs highlight challenges in complex programming concepts, while specific strengths in various topics showcase model distinctions. This research underscores LLMs' value in exercise generation, emphasizing the critical role of human supervision in refining these processes. Our concise insights cater to educators, practitioners, and other researchers seeking to enhance SE education through LLM applications.

The integration of Artificial Intelligence (AI) tech-nologies into educational settings has paved the way for inno-vative teaching and learning approaches. In Software Engineering (SE) education, using Unified Modeling Language (UML) diagrams is a fundamental teaching element for understanding complex software systems. This research addresses ChatGPT's ability to utilize UML class and sequence diagrams to create SE modeling exercises. We use ChatGPT to generate exercises based on the information from uploaded UML diagrams by analyzing textual UML representations such as Mermaid and graphical diagrams. The research explores ChatGPT's ability to synthesize UML-specific information from class and sequence diagrams, enabling the generation of various exercises tailored to strengthen conceptual understanding and practical application. Furthermore, we investigate generating graphical UML class and sequence diagrams based on natural language as input. By bridging the gap between AI -driven natural language understanding and the comprehension of UML diagrams, this study highlights the potential of ChatGPT to improve SE education. Our concise findings address educators, practitioners, and other researchers engaged in the field of SE education with a special focus on UML.

In recent years, artificial intelligence (AI) has been increasingly used in education and supports teachers in creating educational material and students in their learning progress. AI-driven learning support has recently been further strengthened by the release of ChatGPT, in which users can retrieve explanations for various concepts in a few minutes through chat. However, to what extent the use of AI models, such as ChatGPT, is suitable for the creation of didactically and content-wise good exercises for programming courses is not yet known. Therefore, in this paper, we investigate the use of AI-generated exercises for beginner and intermediate programming courses in higher education using ChatGPT. We created 12 exercise sheets with ChatGPT for a beginner to intermediate programming course focusing on the objects-first approach. We report our process, prompts, and experience using ChatGPT for this task and outline good practices we identified. The generated exercises are assessed and revised, primarily using ChatGPT, until they met the requirements of the programming course. We assessed the quality of these exercises by using them in our external teaching assignment course at the University of Education Ludwigsburg and let the students evaluate them. Results indicate the quality of the generated exercises and the time-saving for creating them using ChatGPT. However, our experience showed that while it is fast to generate a good version of an exercise, almost every exercise requires minor manual changes to improve its quality.

Demonstrating the real-time execution of the software in distributed cyber-physical systems like vehicles in a realistic way, e.g., in the context of teaching students at universities, often requires a real car which is costly and hard to acquire. Therefore, we present an approach for using the MechatronicUML to model structural and behavioral aspects of the software for vehicles and generate code that we deploy and run on robot cars in our laboratory environment. We demonstrate this approach with an exemplary application scenario that comprises two vehicles driving on a road and exchanging information to prepare for a cooperative overtaking through a remotely deployed message broker. After adding support for our robot car hardware platform in an existing code generator for MechatronicUML, the robot cars could execute this scenario as envisioned with the generated code. The approach allows us to model distributed cyber-physical systems in a realistic way while demonstrating them in a simplified setup that is accessible to students. A video showcasing this demonstration can be accessed at https://youtu.be/8XgSudDxDB4.

Abstract Modern component-based architectural styles, e.g., microservices, enable developing the components independently from each other. However, this independence can result in problems when it comes to managing issues, such as bugs, as developer teams can freely choose their technology stacks, such as issue management systems (IMSs), e.g., Jira, GitHub, or Redmine. In the case of a microservice architecture, if an issue of a downstream microservice depends on an issue of an upstream microservice, this must be both identified and communicated, and the downstream service’s issues should link to its causing issue. However, agile project management today requires efficient communication, which is why more and more teams are communicating through comments in the issues themselves. Unfortunately, IMSs are not integrated with each other, thus, semantically linking these issues is not supported, and identifying such issue dependencies from different IMSs is time-consuming and requires manual searching in multiple IMS technologies. This results in many context switches and prevents developers from being focused and getting things done. Therefore, in this paper, we present a concept for seamlessly integrating different IMS technologies into each other and providing a better architectural context. The concept is based on augmenting the websites of issue management systems through a browser extension. We validate the approach with a prototypical implementation for the Chrome browser. For evaluation, we conducted expert interviews, which approved that the presented approach provides significant advantages for managing issues of agile microservice architectures.

Despite microservices and other component-based architecture styles being state of the art in research for many years by now, issue management across the boundaries of a single component is still challenging. Components that were developed independently and can be used independently are joined together in the overall architecture, which results in dependencies between those components. Due to these dependencies, bugs can result that propagate along the call chains through the architecture. Other types of issues, such as the violation of non-functional quality properties, can also impact other components. However, traditional issue management systems end at the boundaries of a component, making tracking of issues across different components time-consuming and error-prone. Therefore, a need for automation arises for cross-component issue management, which automatically puts issues of the independent components in the correct mutual context, creating new cross-component issues and syncing cross-component issues between different components. This automation could enable developers to manage issues across components as efficiently as possible and increases the system’s quality. To solve this problem, we propose an initial approach for semi-automated cross-component issue management in conjunction with service-level objectives based on our Gropius system. For example, relationships between issues of the same or different components can be predicted using classification to identify dependencies of issues across component boundaries. In addition, we are developing a system to model, monitor and alert service-level objectives. Based on this, the impact of such quality violations on the overall system and the business process will be analysed and explained through cross-component issues.