Publications

Agentic AI introduces new forms of autonomy, adaptivity, and decision-making that fundamentally reshape how business processes are designed, enacted, and governed. Rather than replacing established BPM concepts, agentic systems extend the process lifecycle through runtime decision-making and hybrid human–AI execution, often realized through multi-agent and context-aware architectures. This evolution raises challenges for process architectures, control mechanisms, accountability, and governance in increasingly autonomous process environments. AXPRO addresses these challenges by focusing on agentic AI as a key driver of adaptive and decision-centric business processes. We invite conceptual, empirical, and technical contributions exploring architectures, methods, and evaluation approaches for agentic AI–enabled processes across analysis, modeling, execution, monitoring, and redesign. AXPRO aims to advance theory and practice for next-generation process and information systems.

Advancing capabilities of generative AI pose existential challenges to structures, roles, practices, and narratives established in higher education. Simultaneously, developments ranging from LLM-based chatbots, autonomous agents and multi-agent systems to adaptive tutoring systems and AI-supported analytics also open transformative opportunities for universities to redefine teaching, learning, competencies, assessment, academic integrity, and strategic governance. This Special Session AI4HE addresses these challenges and opportunities by exploring the meaningful integration of AI in universities by combining technological, organizational and educational perspectives. We welcome research on generative AI, intelligent agents and tutors, AI-supported assessment and feedback, institutional transformation, AI literacy, and competence frameworks. The session embraces diverse approaches including conceptual work, theoretical models, empirical studies, case reports, and technical implementations.

The Special Session HAIDX focuses on the dynamics of decision-making in human–AI constellations, especially within complex and multi-agent environments. We invite contributions exploring cognitive, behavioral, interactional, and computational dimensions of how humans and AI systems coordinate decisions, share agency, manage resources, build trust, and resolve uncertainty. The session welcomes interdisciplinary perspectives from fields such as HCI, psychology, AI engineering, multi-agent systems, process management, game theory, and organizational behavior. Of particular interest are models, frameworks, empirical studies, experimental designs, and technical implementations that explain, analyze, or enhance human–AI decision dynamics under conditions of high-complexity. HAIDX aims to connect researchers across disciplines to advance a deeper understanding of hybrid decision ecosystems.

The evolving expectations within gaming communities drive ongoing research and development efforts to devise innovative methods for constructing intricate gameful systems. These methods incorporate cutting-edge technologies like AI, AR/VR, and biometrics, to meet the needs of gaming communities. Gameful systems encompass three main categories: entertainment games, which offers captivating user experiences aimed at immersing and retaining players; serious games, which combines the entertainment aspect of gaming with specific goals in domains such as education, training, and healthcare; and gamified applications, which augments non-entertainment applications, like learning management systems, by integrating game elements. The 8th International Workshop on Games and Software Engineering (GAS 2024), co-located with ICSE 2024, is an annual event that brings together interdisciplinary researchers and practitioners to explore issues that crosscut the software engineering and game development communities. The workshop website is https://sites.google.com/view/gas-2024.

The rapidly evolving capabilities of generative artificial intelligence (AI) in understanding and generating texts and images challenge the role of human competences in existing and redesigned processes and infrastructures in many domains. In addition to aspects such as automating complex tasks and decision-making processes, the question arises as to which human competences are required to deal efficiently and confidently with these newly emerging AI-driven opportunities, manifesting in form of new tools, methods, processes and infrastructures, including the design and use of hybrid human-AI ecosystems. A variety of digital competence frameworks (DCFWs) is available to support practitioners from didactic and business contexts in specifying and measuring such competences. In this paper, we systematically analyze established DCFWs and compare the provided means to cope with the challenges from rapidly evolving generative AI. For this purpose, we present the results of a systematic mapping study (SMS) based on 25 identified international DCFWs, focusing on the degree of AI coverage and adaptability. The resulting structural overview and comparative analysis provides orientation and aims to empower both individual practitioners and organizations to evaluate, select, combine, contextualize, adapt and apply existing frameworks based on their individual application purposes.

Decision-making is a fundamental capability in everyday life. Large Language Models (LLMs) provide multifaceted support in enhancing human decision-making processes. However, understanding the influencing factors of LLM-assisted decision-making is crucial for enabling individuals to utilize LLM-provided advantages and minimize associated risks in order to make more informed and better decisions. This study presents the results of a comprehensive literature analysis, providing a structural overview and detailed analysis of determinants impacting decision-making with LLM support. In particular, we explore the effects of technological aspects of LLMs, including transparency and prompt engineering, psychological factors such as emotions and decision-making styles, as well as decision-specific determinants such as task difficulty and accountability. In addition, the impact of the determinants on the decision-making process is illustrated via multiple application scenarios. Drawing from our analysis, we develop a dependency framework that systematizes possible interactions in terms of reciprocal interdependencies between these determinants. Our research reveals that, due to the multifaceted interactions with various determinants, factors such as trust in or reliance on LLMs, the user’s mental model, and the characteristics of information processing are identified as significant aspects influencing LLM-assisted decision-making processes. Our findings can be seen as crucial for improving decision quality in human-AI collaboration, empowering both users and organizations, and designing more effective LLM interfaces. Additionally, our work provides a foundation for future empirical investigations on the determinants of decision-making assisted by LLMs.

Large language models (LLMs) have revolutionized the field of artificial intelligence, endowing it with sophisticated language understanding and generation capabilities. However, when faced with more complex and interconnected tasks that demand a profound and iterative thought process, LLMs reveal their inherent limitations. Autonomous LLM-powered multi-agent systems represent a strategic response to these challenges. Such systems strive for autonomously tackling user-prompted goals by decomposing them into manageable tasks and orchestrating their execution and result synthesis through a collective of specialized intelligent agents. Equipped with LLM-powered reasoning capabilities, these agents harness the cognitive synergy of collaborating with their peers, enhanced by leveraging contextual resources such as tools and datasets. While these architectures hold promising potential in amplifying AI capabilities, striking the right balance between different levels of autonomy and alignment remains the crucial challenge for their effective operation. This paper proposes a comprehensive multi-dimensional taxonomy, engineered to analyze how autonomous LLM-powered multi-agent systems balance the dynamic interplay between autonomy and alignment across various aspects inherent to architectural viewpoints such as goal-driven task management, agent composition, multi-agent collaboration, and context interaction. It also includes a domain-ontology model specifying fundamental architectural concepts. Our taxonomy aims to empower researchers, engineers, and AI practitioners to systematically analyze, compare, and understand the architectural dynamics and balancing strategies employed by these increasingly prevalent AI systems, thus contributing to ongoing efforts to develop more reliable and efficient solutions. The exploratory taxonomic classification of selected representative LLM-powered multi-agent systems illustrates its practical utility and reveals potential for future research and development.

Large language models (LLMs) have revolutionized the field of artificial intelligence, endowing it with sophisticated language understanding and generation capabilities. However, when faced with more complex and interconnected tasks that demand a profound and iterative thought process, LLMs reveal their inherent limitations. Autonomous LLM-powered multi-agent systems represent a strategic response to these challenges. While these architectures hold promising potential in amplifying AI capabilities, striking the right balance between different levels of autonomy and alignment remains the crucial challenge for their effective operation. This paper proposes a comprehensive multi-dimensional taxonomy, engineered to analyze how autonomous LLM-powered multi-agent systems balance the dynamic interplay between autonomy and alignment across various aspects inherent to architectural viewpoints such as goal-driven task management, agent composition, multi-agent collaboration, and context interaction. Our taxonomy aims to empower researchers, engineers, and AI practitioners to systematically analyze the architectural dynamics and balancing strategies employed by these increasingly prevalent AI systems. The exploratory taxonomic classification of selected representative LLM-powered multi-agent systems illustrates its practical utility and reveals potential for future research and development. An extended version of this paper is available on arXiv (Händler, 2023).

This workshop summary refers to the 1st International Workshop on Games for Software Engineering Education and Training (SE-Games 2020), co-located with the 32nd IEEE International Conference on Software Engineering Education & l Training (CSEE&T 2020). SE-Games aims to serve as a platform for researchers and practitioners, who share the goal to improve the methods of teaching and training software engineering by designing and applying game-based environments such as serious games, game-based learning and gamification.

Despite being regarded as necessary to ensure a system’s maintainability and extensibility, software refactoring is often neglected in practice due to difficulties and risks perceived by software developers. Still, refactoring received little attention by software engineering education and training so far. Educational games are a popular means for enhancing practical competences as well as increasing motivation of learners. For instructors, however, it is challenging to develop and apply games in order to address certain learning objectives, which is important to integrate the games into existing or planned training paths. In this article, we propose an ontology that aims to support the analysis and design of games for teaching and training software refactoring. In particular, we create a unifying domain ontology bridging core concepts from three related fields, i.e. game design (a), software refactoring (b), and competence management (c). The resulting ontology is represented as a UML class diagram that reflects concepts and concept relations important for educational refactoring games. We describe ontology-based design options and demonstrate the use of the ontology by analyzing existing games for software refactoring. In addition, we also present an exemplary process for developing novel games based on the ontology and illustrate its applicability by designing a non-digital card game.

While software refactoring is considered important to manage software complexity, it is often perceived as difficult and risky by software developers and thus neglected in practice. In this article, we present refacTutor, an interactive tutoring system for promoting software developers’ practical competences in software refactoring. The tutoring system provides immediate feedback to the users regarding the quality of the software design and the functional correctness of the (modified) source code. In particular, after each code modification (refactoring step), the user can review the results of run-time regression tests and compare the actual software design (as-is) with the targeted design (to-be) in order to check quality improvement. For this purpose, structural and behavioral diagrams of the Unified Modeling Language (UML2) representing the as-is software design are automatically reverse-engineered from source code. The to-be UML design diagrams can be pre-specified by the instructor. To demonstrate the technical feasibility of the approach, we provide a browser-based software prototype in Java accompanied by a collection of exercise examples. Moreover, we specify a viewpoint model for software refactoring, allocate exercises to competence levels and describe an exemplary path for teaching and training.

DevOps aims to increase an organization’s ability to build, test and release software in a rapid, frequent, and more reliable fashion by combining the perspectives of software development and IT operations. It emphasizes the communication and collaboration among all stakeholders involved in the software development lifecycle by applying a set of technological and cultural practices and principals. Organizations are increasingly adopting DevOps practices in order to capitalize on its benefits. However, DevOps is a paradigm with different interpretations and definitions, making it difficult for organizations to decide what practices and capabilities of DevOps to adopt and to enhance based on their individual business needs. In this paper, we propose a GQM-based approach for assessing the DevOps maturity in organizations. For this purpose, we structure DevOps capabilities in terms of goals and sub-goals that enable DevOps identified in existing research literature. Then, questions and metrics are derived and operated for a questionnaire to assess the DevOps maturity with regard to the different capability levels. The resulting maturity report is finally illustrated via different kinds of radar charts representing the individual levels of the identified goals and sub-goals. A first evaluation with experts indicates that the developed technique seems useful to assess DevOps maturity. With the support of the proposed technique, organizations are able to assess its current practices and measure the improvements over the course of time.

While software refactoring is considered important to keep a software system maintainable and extensible, it is often neglected in practice due to several reasons. Besides the associated costs, software developers often perceive refactoring as a difficult and risky activity. However, apart from textbooks that document rules and best practices for identifying bad smells and applying appropriate refactoring techniques, learning and teaching refactoring poses multiple challenges. The application of these rules and techniques to code examples requires (advanced) skills in programming as well as an adequate handling of the programming environment. These circumstances can distract the focus and set barriers to the introduction of refactoring. In this paper, we present REFACTORY, a nondigital multi-player card game for learning principles of software refactoring without the development-related complexities. In our game, the players simulate a software-development team confronted with bad code smells. The players learn to combine refactoring techniques to remove the smells and to balance costs and value of refactoring. We specify the game design and illustrate the game workflow. In addition, experiences and lessons learned from a first game-play study are presented, eg regarding game fun and mediation of competences. Finally, we discuss limitations and further potential for improving the game.

Over time, software systems can become increasingly complex due to ongoing changes and extensions, which often makes them difficult to maintain for software developers. In particular, issues and flaws (such as bad smells) in source code or software design and architecture can negatively impact a system's maintainability and evolvability, which can lead to a massive cost increase of software projects (by accumulating a system's technical debt). Although software refactoring is widely considered important to manage complexity and to improve the internal quality of software systems by removing these issues, it is often neglected in practice. Among other reasons (such as the associated costs), refactoring is often perceived by software developers as a difficult and risky activity. This PhD thesis addresses the need for software developers to be competent in performing software-refactoring activities efficiently. Its objective is to investigate how interactive game-based teaching and training environments can be developed and applied to support developers in acquiring and improving practical competences in software refactoring. For this purpose, research techniques from the fields of information systems, software engineering as well as (software-engineering) education and training are combined. Basically, the project is guided by the design-science research methodology (DSRM), which basically consists in the development and evaluation of artifacts that aim at addressing certain problems or challenges considered relevant. For the design and development of artifacts, we combine techniques of analytic and conceptual investigation (e.g. based on literature reviews) resulting in conceptual artifacts such as process models and competence frameworks as well as exploratory and prototypical investigation (e.g. in terms of software prototyping) resulting in concrete game-based training environments such as tutoring systems or serious games. Different evaluation techniques are then applied to demonstrate the use and effectiveness of the artifacts. For example, the artifacts are evaluated technically (e.g. via proof-of-concept implementations), conceptually (e.g. by allocating the competence levels addressed) as well as partially in terms of feedback from users of the environments (e.g. via surveys). In sum, this cumulative PhD thesis comprises 10 peer-reviewed research papers and articles, which have been presented at international scientific conferences and published in corresponding books and proceedings. The thesis contributes to the body-of-knowledge in software-engineering education and training (SEET) by investigating the challenges and opportunities of interactive and game-based environments for training of software refactoring, which is highly relevant from industrial and scientific perspectives (cf. technical debt), but neglected in SEET so far. The results indicate further potential for future research as well as for practical usage for teaching and training software developers.

Long-living software systems are becoming increasingly complex and difficult to maintain. Software refactoring is considered important to achieve maintainability and extensibility of a software system over time. Inpractice, it is still often neglected, partly because of costs, the perceived risks of collateral damage and difficulties of individuals working on certain components of complex software. It is therefore important for software projects that software developers have the appropriate skills and competences to efficiently perform softwarere factoring. However, so far there is no systematization of competences in software refactoring to guide in the assessment or training of competences, e.g., for planning or evaluating training activities and paths. In this paper, we address this need by presenting a competence framework for software refactoring by applying Bloom’s revised taxonomy for educational objectives. In particular, we specify competence levels by combining knowledge and cognitive-process dimensions. Via a case study with two existing training environments (i.e. a tutoring system and a serious game), we demonstrate by example that the framework can support (1) in analyzing the competence levels addressed by the training environments and (2) in reflecting training paths for software refactoring. Finally, we discuss the limitations and the further potential of the framework.

Acquiring practical competences in computer programming and software engineering is challenging. Software refactoring, in particular, is considered an important and useful quality-assurance technique, but due to the perceived difficulties and risks of performing it, often neglected in practice. Still, it received little attention by software engineering education and training so far. Games are a popular means for fostering motivation as well as mediating and improving practical competences by providing an enjoyable and playful environment. However, for instructors it is challenging to develop and apply game designs that address certain learning objectives, which is important for integrating the game into existing or planned learning and training paths, e.g. in the framework of university courses or training units for (experienced) software developers. In this paper, we propose an ontology that aims to support the analysis and design of games in the field of software refactoring. We apply a structured process for creating a unifying domain ontology bridging core concepts from three related fields, i.e. game design (a), software refactoring (b), and competence management (c). The resulting ontology is then represented as a meta-model in terms of a UML class diagram and reflects concepts important for refactoring-game designs. We describe ontology-based options for game design and illustrate the use of the ontology by analyzing existing refactoring-gaming approaches. In addition, we reflect applying the ontology for reasoning about novel game designs and discuss further potential of the approach.

Although considered useful and important, software refactoring is often neglected in practice because of the perceived risks and difficulties of performing it. A way to address these challenges can be seen in promoting developers’ practical competences. In this paper, we propose an approach for an interactive training environment for addressing practical competences in software refactoring. In particular, we present a tutoring system that provides immediate feedback to the users (e.g. university students or software developers) regarding the software-design quality and the functional correctness of the (modified) source code. After each code modification (refactoring step), the user can review the results of run-time regression tests and compare the actual software design (as-is) with the targeted design (to-be) in order to check quality improvement. For this purpose, structural and behavioral diagrams of the Unified Modeling Language (UML2) representing the as-is software design are automatically reverse-engineered from source code. The to-be design diagrams (also in UML) can be pre-specified by the instructor. We illustrate the usability of the approach for training competences in refactoring via short application scenarios and describe exemplary learning paths. Moreover, we provide a web-based software-technical implementation in Java (called refacTutor) to demonstrate the technical feasibility of the approach. Finally, limitations and further potential of the approach are discussed.

This summary refers to the paper Serious Refactoring Games published as a full research paper in the proceedings of the 52nd Hawaii International Conference on System Sciences (HICSS 2019) [HN19]. Software design issues can severely impede software development and maintenance. Thus, it is important for the success of software projects that developers are aware of bad smells in code artifacts and improve their skills to reduce these issues via refactoring. However, software refactoring is a complex activity and involves multiple tasks and aspects. Therefore, imparting competences for identifying bad smells and refactoring code efficiently is challenging for software engineering education and training. The approaches proposed for teaching software refactoring in recent years mostly concentrate on small and artiĄcial tasks and fall short in terms of higher level competences, such as analysis and evaluation. In this paper, we investigate the possibilities and challenges of designing serious games for software refactoring on real-world code artifacts. In particular, we propose a game design, where students can compete either against a predeĄned benchmark (technical debt) or against each other. In addition, we describe a lightweight architecture as the technical foundation for the game design that integrates pre-existing analysis tools such as test frameworks and software-quality analyzers. Finally, we provide an exemplary game scenario to illustrate the application of serious games in a learning setting.

Software design issues can severely impede softwaredevelopment and maintenance. Thus, it is important for the success of software projects that developers are aware of bad smells in code artifacts and improve their skills to reduce these issues via refactoring. However, software refactoring is a complex activity and involves multiple tasks and aspects. Therefore, imparting competences for identifying bad smells and refactoring code efficiently is challenging for software engineering education and training. The approaches proposed for teaching software refactoring in recent years mostly concentrate on small and artificial tasks and fall short in terms of higher level competences, such as analysis and evaluation. In this paper, we investigate the possibilities and challenges of designing serious games for software refactoring on real-world code artifacts. In particular, we propose a game design, where students can compete either against a predefined benchmark (technical debt) or against each other. In addition, we describe a lightweight architecture as the technical foundation for the game design that integrates pre-existing analysis tools such as test frameworks and software-quality analyzers. Finally, we provide an exemplary game scenario to illustrate the application of serious games in a learning setting.

Deficiencies in software design or architecture can severely impede and slow down the software development and maintenance progress. Bad smells and anti-patterns can be an indicator for poor software design and suggest for a refactoring of the affected source code fragment. In recent years, multiple techniques and tools have been proposed to assist software engineers in identifying smells and guiding them through corresponding refactoring steps. However, these detection tools so far only cover a modest amount of smells and also tend to produce false positives which represent conscious constructs with symptoms similar or identical to actual bad smells (e.g. design patterns). These and other issues in the detection process demand for a code or design review in order to identify (missed) design smells and/or re-assess detected smell candidates. UML diagrams are the quasi-standard for documenting software design and are often available in software projects. In this position paper, we investigate whether (and to what extent) UML diagrams can be used for identifying and assessing design smells. Based on a description of difficulties in the smell detection process, we discuss the importance of design reviews. We then investigate to what extent design documentation in terms of UML2 diagrams allows for representing and identifying software design smells. In particular, 14 kinds of design smells and their representability via UML class and sequence diagrams are analyzed. In addition, we discuss further challenges for UML-based identification and assessment of bad smells.

Refactoring is the process of improving a software system’s internal technical quality by modifying and restructuring a system’s source code without changing its external behavior. Manual identification and assessment of refactoring candidates as well as planning and performing the refactoring steps are complex and tedious tasks, for which several tools and techniques for automation and decision support have been proposed in recent years. Despite these advances, refactoring is still a neglected part of software engineering in practice, which is attributed to several barriers that prevent software practitioners from refactoring. In this paper, we present an approach for deconstructing the refactoring process into decision-problems and corresponding decision-making sub-processes. Within this, we pursue the question of whether and how a theoretical perspective can contribute to better understand the difficulties in the refactoring process (barriers) and to help improving the refactoring support techniques (enablers). For this purpose, we follow a deductive reasoning approach by applying concepts from decision-making research to deconstruct the refactoring process. As a result, we present a process model, which integrates primary decision problems and corresponding decisionmaking sub-processes in refactoring. Based on this process model, software companies can gain a better understanding of decision-making in the refactoring process. We finally discuss the applied procedure and reflect on limitations and potential of applying such a theoretical perspective.

Managing technical debt includes the detection and assessment of debt at the code and design levels (such as bad smells). Existing approaches and tools for smell detection primarily use static program data for decision support. While a static analysis allows for identifying smell candidates without executing and instrumenting the system, such approaches also come with the risk of missing candidates or of producing false positives. Moreover, smell candidates might result from a deliberate design decision (e.g., of applying a particular design pattern). Such risks and the general ambivalence of smell detection require a manual design and/or code inspection for reviewing all alleged smells. In this paper, we propose an approach to obtain tailorable design documentation for object-oriented systems based on runtime tests. In particular, the approach supports a tool-supported triaging of code-smell candidates. We use runtime scenario tests to extract execution traces. Based on these execution traces, different (automatically derived) model perspectives on method-call dependencies (e.g., dependency structure matrices, DSMs; UML2 sequence diagrams) are then used as decision support for assessing smell candidates. Our approach is implemented as part of the KaleidoScope tool which is publicly available for download.

In this paper, we present a model-driven approach for the derivation of inter-component-interaction specifications from runtime tests. In particular, we use test-execution traces to record interactions between architectural components based on testing object-oriented systems. The resulting models are specified via UML diagrams. In order to transform test executions to corresponding component and interaction models, we define conceptual mappings (transformation rules) between a test-execution metamodel and the UML2 metamodel. As a proof of concept, we integrated the approach into our KaleidoScope tool.

Documenting system behavior explicitly using graphical models (e.g. UML activity or sequence diagrams) facilitates communication about and understanding of software systems during development and maintenance tasks. Creating graphical models manually is a timeconsuming and often error-prone task. Deriving models from systemexecution traces, however, suffers from resulting model sizes which render the models unmanageable for humans. This paper describes an approach for deriving behavior documentation from runtime tests in terms of UML interaction models. Key to our approach is leveraging the structure of scenario-based runtime tests to render the resulting interaction models and diagrams tailorable by humans for a given task. Each derived model represents a particular view on the test-execution trace. This way, one can benefit from tailored graphical models while controlling the model size. The approach builds on conceptual mappings (transformation rules) between a test-execution trace metamodel and the UML2 metamodel. In addition, we provide means to turn selected details of test specifications and of testing environment (i.e. test parts and call scopes) into views on the test-execution trace (scenario-test viewpoint). A prototype implementation called KaleidoScope based on a software-testing framework (STORM) and model transformations (Eclipse M2M/QVTo) is available.

Documenting system behavior explicitely using graphical models (e.g. UML activity or sequence diagrams) facilitates communication about and understanding of software systems during development or maintenance. Creating graphical models manually is a time-consuming and often error-prone task. Deriving models from system-execution traces, however, suffers from the problem of model-size explosion. We propose a modeldriven approach for deriving behavior documentation in terms of UML interaction models from runtime tests in a semi-automated manner. Key to our approach is leveraging the structure of scenario-based tests for model and diagram derivation. Each derived model represents a particular view on the test-execution trace. This way, one can benefit from derived graphical models while making the resulting model size manageable. In this paper, we define conceptual mappings between a test-execution trace metamodel and the UML2 metamodel. In addition, we provide means to turn selected details of test specifications and testing environment into views on the test-execution trace (scenario-test viewpoint). The feasibility of our approach is demonstrated by a prototype implementation (KaleidoScope), which builds on an existing software-testing framework (STORM) and model transformations (Eclipse M2M/QVTo).