We are pleased to introduce the 2024 36th International Conference on Software Engineering Education and Training (CSEE&T) held in Würzburg, Germany, from July 29thto August 1st, 2024.

Learning software project management skills can be supported in various of ways. In particular, using business games or simulators represents added value in the classroom but also has some drawbacks and should be supported by an adequate didactic concept. This paper summarizes extensive data collected over nearly two decades from the AMEISE simulation environment used in European universities. It focuses on the output of simulation runs and aims to achieve three objectives: first, reporting on the setting, secondly, sharing lessons learned; and, finally, providing 34 recommendations for educational and training contexts. The paper starts by describing the simulation environment and its use in the lectures over the past 20 years; then, it presents an analysis of qualitative data collected, showing that, according to students, the simulation is one of the best parts of a course. Following the structure of a typical didactic handout, challenges in preparation and implementation, as well as external factors influencing the quality of teaching, are then highlighted, and approaches to solutions or improvements are systematically derived. Most of the recommendations in this paper also apply to courses without simulators, which can improve software engineering education in the long term.

Many Java programs encode temporal behaviors in their source code, typically mixing three features provided by the Java language: (1) pausing the execution for a limited amount of time, (2) waiting for an event that has to occur before a deadline expires, and (3) comparing timestamps. In this work, we show how to exploit modern SMT solvers together with static analysis in order to produce a network of timed automata approximating the temporal behavior of a set of Java threads. We also prove that the presented abstraction preserves the truth of MTL and ATCTL formulae, two well-known logics for expressing timed specifications. As far as we know, this is the first feasible approach enabling the user to automatically model check timed specifications of Java software directly from the source code.

In industry, the benefit of maturity models is uncontested, and models like CMMI are normally taught in at least advanced Software Engineering courses. However, when not being part of real-world projects, the added values are difficult to be experienced on first hand by our students. In this paper we report on a study and teaching approach where, in three successive semesters and at two different institutions, we started rating the process-maturity of students solving tasks in our software engineering courses and transparently related the maturity levels to the task performances. It turned out that there is a non-negligible correlation between the individual process maturity and performances. Considering this finding, the approach might yield to students' process-improvement steps during our courses, help in fostering the understanding of the term process maturity, and finally, also might help in improving the overall students' performances.

Because of the present deep impact of information technology on society, school subjects that deal with topics of computer science or digital literacy gain importance nowadays. Some countries start to teach related topics in primary education and even in kindergarten. The underlying curricula, educational standards and/or competency models have already been developed and established and differ in a lot of points. Because of these differences, a comparison is a complex task. In this paper a graph-based approach is applied to introduce a framework for comprehensibly evaluating the different curricula, standards and competency models and to demonstrate its use by analyzing and comparing six existing curricula, standards and competency models. Our approach maps the content of curricula and standards to a directed graph by connecting their knowledge items with each other via dependency relations. This method enables a formalized comparison using graph theoretical metrics like the highest degrees, numbers of sources and sinks, or the connectivity. The representation is mapped to a graph database, allowing for further analysis of the content and preparing the ground for teachers and curriculum-developers to individually form a computer science curriculum in primary schools.

A growing number of countries start to introduce computer science related topics in primary education, but their curricula or educational standards significantly differ in various aspects. This contribution introduces a way to analyze and compare curricula, education standards and competency models, using a graph-based representation form and several graph-theoretical metrics.

Software Engineering is definitely an important subject matter and it is taught all over the world: at Universities, at Colleges, and recently also at High Schools. There are international Software Engineering curricula, standards, and certificates, but there is no manifestation of Software Engineering (and related practices) in the course syllabi at primary and secondary schools. There are good reasons for it, but based on the authors' experiences gained in combining Software Engineering topics with school projects and based on discussions with teachers and curriculum designers, this paper shows that informatics education can be much more than just programming. Even more, the paper shows that it makes sense to interweave Software Engineering topics with school projects and to motivate for the most important practices related to that field.

This half-day tutorial shows how a flexible and scalable simulation environment can be applied to train project management skills in a realistic way by simulating problems practitioners are facing in their daily work. Based on the simulation goals, the participants act as project managers determining the simulated development process by adequate staffing and allocating software development as well as quality assurance tasks.

Software is everywhere - be it in mobile phones, in washing machines, or in cars. With it, the importance of Software Engineering is uncontested, and Software Engineering (SE) is taught all over the world: at Universities, at Colleges, and recently also at High Schools. There are international Software Engineering curricula, standards, and certificates, but there is no manifestation of Software Engineering (and related practices) in the course syllabi at primary and secondary schools. This contribution raises the question about the ideal time to start with Software Engineering at schools and reports on some first answer and lessons learned of an experiment introducing Software Engineering principles in the 3rd grade of a vocational high school (higher secondary school).

This half-day tutorial shows how a flexible simulation environment can link the various topic areas of software engineering in the same way they are interwoven in the daily work of practitioners. Based on the simulation goals, the participants act as project managers determining the simulated development process by adequate staffing and allocating software development as well as quality assurance tasks.

SUMMARY This article proposes metrics for quantifying changes throughout the evolution of formal software specifications in long living systems. Formal specifications play an important role in the software development life‐cycle by supporting refinement and proof and by providing a basis for comprehension and maintenance activities. However, specifications also undergo evolutionary changes, and these changes are hard to assess because of a lack of suitable measures. This paper proposes and analyzes a set of measures for estimating aspects of a specification's complexity and quality. The measures are based on existing measures for source code, but they have been redefined in the scope of formal Z specifications. Geared towards Z, they are then evaluated concerning their expressiveness by a case study that comprises more than 65,000 lines of specification text. Finally, the usability of the measures is demonstrated on the Z specification of the Web Service Definition Language during its evolution over a period of about 3 years. Copyright © 2013 John Wiley & Sons, Ltd.

Software Engineering education must account for a broad spectrum of knowledge and skills software engineers will be required to apply throughout their professional life. Covering all the topics in depth within a university setting is infeasible due to curricular constraints as well as due to the inherent differences between educational institutions and the actual workplaces of individual graduates. This paper shows how a flexible simulation environment can link the various topic areas of software engineering in the same way they are interwoven in the daily work of practitioners. The authors report their experience gained in using such an environment in their courses at their different institutions, each one having a very distinct focus. Customization of the environment and respective didactical changes can address students with different maturity levels, educational aims, and backgrounds.

The AMEISE (A Media Education Initiative for Software Engineering) approach focuses on the simulation of software project management processes. Based on Stuttgart University's SESAM (Software Engineering Simulation by Animated Models), the AMEISE tool-set allows for repeatedly experiencing the complexity of software project management within a game-like simulation environment.

An experience-dominated subject like software project management cannot be learned by merely attending lectures. Additional labs, however, even with only modest real-life projects, call for substantial effort to be spent by the instructors as well as by the partaking students. Our experience shows that using a software development simulation tool enhances the mix of methods used in conventional teaching substantially.

Abstract When kept up‐to‐date, formal specifications can act as valid artifacts for maintenance tasks. However, their linguistic density and size impede comprehension, reuse, and change activities. Techniques such as specification slicing and chunking help in reducing the number of relevant lines of text to be considered, but they expect the point of change to be known a priori. This contribution presents a process model for concept location within formal Z‐specifications. It also considers those situations when the location is not even roughly known. The identification is comparable to the identification of regions with high cohesion. The approach is based on the idea of first transforming the specification to an augmented graph and, secondly, on the generation of spacial clusters. Copyright © 2008 John Wiley & Sons, Ltd.

Being part of different maintenance models formal specifications can act as valid artifacts for maintenance tasks. However, the linguistic density of specification languages and the size of specifications might still be seen as an obstacle against comprehension, reuse, and change activities. This paper introduces an approach for the identification of specification fragments of Z specifications with a well defined semantic content. These fragments, namely specification chunks and specification slices, not only support comprehension tasks, they also enable maintenance personnel to identify and focus on the relevant parts of specifications for the problem at hand. Their ease in creation and use makes them well suited for maintenance, as is demonstrated by a simple prototype for Z specifications.