The interdisciplinary design of intralogistics systems (ILS) involves engineers from various disciplines, resulting in the generation of discipline-specific model files with overlapping information. For instance, a conveyor system can be represented from various perspectives, such as 3D-CAD models that capture its geometric information and discrete-event simulation models that depict the system’s dynamic material flow performance. The growing demands for flexible reconfigurability and adaptability in intralogistics systems necessitate frequent updates to engineering models. However, these updates often result in potential model inconsistencies due to insufficient stakeholder communication. Detecting the impact of model changes and related inconsistencies is challenging in practice due to data heterogeneity and complex inter-model relations. To address these challenges, we propose an ontology-versioning approach that automates the identification of inconsistencies resulting from model changes. Our approach facilitates the integration of heterogeneous model data, enables database versioning, detects inconsistencies caused by model updates, and provides traceability for identified issues. The concept is evaluated utilizing models from a prototypical implementation on a lab-sized demonstrator.Note to Practitioners—In the industry, the current development of intralogistics systems often lacks automated synchronization of overlapping model information and consistent model interfaces, frequently leading to contradictions among the models. This has been identified as a significant source of errors in the design of both industrial and academic intralogistics systems, as revealed by a study involving intralogistics experts from different technical disciplines. Effectively managing model inconsistencies is crucial for project success, particularly when frequent model changes occur. A promising approach to tackle this issue is to systematically link model data from different disciplines, through which model inconsistencies caused by inadequate communication among engineers can be identified and prevented. However, in many cases, changes in different model versions and their resulting inconsistencies are not adequately considered. To address this issue, we propose a concept based on ontology versioning that allows for the generation, comparison, and analysis of different versions of an ontological model database. This concept automatically identifies model changes, assesses their impacts on other models, and provides information to assist engineers in problem-solving. The effectiveness of our approach is assessed through an evaluation of three representative change scenarios, simplified from real-world use cases. In future research, we plan to extend the approach to general production systems and incorporate industrial-scale models from the broad range of disciplines involved in the design process.

We use learning data of an e-assessment platform for an introductory mathematical statistics course to predict the probability of passing the final exam for each student. Subsequently, we send warning emails to students with a low predicted probability to pass the exam. We detect a positive but imprecisely estimated effect of this treatment, suggesting the effectiveness of such interventions only when administered more intensively.

Automated Assessment Systems (AAS) are increasingly used in large computer science lectures to evaluate student solutions to programming assignments. The AAS normally carries out static and dynamic analysis of the program code. In addition, simple forms of learning analytics can often be generated quite easily. However, structural analyses and comparison of solutions for larger sets of student programs are, in many cases, complicated and time-consuming. In this article, we introduce a methodology with which thousands of programs can be analyzed in less than a second, for example, to search for the use of certain control structures or the application of recursion. For this purpose, we have developed a software that creates a structural representation for each programming solution in the form of a TGraph, which is inserted into a graph database using Neo4j. On this database, we can search for structural features by queries in the language Cypher. We have tested this methodology extensively for Java programs, measured its performance, and validated the results. Our software can also be applied to programs in other programming languages, such as Scratch. Additionally, we plan to make our software available to the community.

To overcome the shortage of computer specialists, there is an increased need for correspondent study and training offers, in particular for learning programming. The automated assessment of solutions to programming tasks could relieve teachers of time-consuming corrections and provide individual feedback even in online courses without any personal teacher. The e-assessment system JACK has been successfully applied for more than 12 years up to now, e.g., in a CS1 lecture. However, there are only few solid research results on competencies and competence models for object-oriented programming (OOP), which could be used as a foundation for high-quality feedback.In a joint research project of research groups at two universities, we aim to empirically define competencies for OOP using a mixed-methods approach. In a first step, we performed a qualitative content analysis of source code (sample solutions and students’ solutions) and as a result identified a set of suitable competency components that forms the core of further investigations. Semi-structured interviews with learners will be used to identify difficulties and misconceptions of the learners and to adapt the set of competency components. Based on that we will use Item Response Theory (IRT) to develop an automatically evaluable test instrument for the implementation of abstract data types. We will further develop empirically founded and competency-based feedback that can be used in e-assessment systems and MOOCs.

At least since the first PISA surveys, the intentions of education are increasingly expressed in terms of competencies instead of learning goals. In consequence, learning outcomes should be measured in terms of these intended competencies as well. This holds for large-scale investigations like PISA as well as for the very small scale that is represented by the examinations that a single teaching person performs with his/her students. Yet, to assure validity, competency measurement requires proper models for competency structure and levels, which are based on empirical research. The goal of this project is to identify a set of relevant competencies in the domain of object-oriented programming (OOP), to develop a suitable competency model to represent their structure and to construct proper corresponding test instruments. This paper describes a study on the outcomes of several assignments that represents one step of this process with focus on the subdomain of data structures. The data were collected during an introductory lecture on programming in the winter term 2015/16. We analyzed the student solutions of three mini-projects that deal with the implementation of abstract data, applying a specific e-assessment system to score the students' solutions. To find suitable item sets that could be used for the definition and measurement of certain competencies, different methodologies were applied that are based on classical test theory as well as on contemporary Item Response Analysis. Up to now, several suitable item sets for the competencies were identified, which are required to implement and operate 1- and 2-dim arrays, linked lists, and binary trees.

Software Engineering (SE) education shapes the perspectives taken by future software engineers. SE processes/methods represent an important knowledge area demanded by industry and curriculum guidelines but belong to those knowledge areas, which are challenging to be taught intuitively accessible. Just providing islands of knowledge is not sufficient in SE education. It has to provide students with the ability to focus on details demanded by stakeholders, technology, and the project environment but to keep a holistic view of the SE endeavor at the same time. To develop demanded competencies - knowledge, skills, and attitudes - SE education has to enable learning experiences where concepts, methods, and tools are perceived as actually supportive, providing orientation and guidance. Taking the high and increasing number of varying existing SE processes/methods into account, the knowledge provided has to be highly transferable to prepare students for their future SE endeavors. This paper presents the results of a case study conducted in summer semester 2016 to evaluate an Integrated Approach introducing students to SE methods based on simulation, Digital Game-Based Learning (DGBL), and SEMAT Essence.

While traditional project planning approaches focus on precise scheduling of tasks, the ESSENCE standard proposes a higher-level approach that focuses on monitoring. Hence, a new kind of process visualization that picks up ideas of Kanban boards and physical cards is sketched in the standard. This tool paper presents a dashboard application refining, extending, and implementing these ideas based on five use cases posed by two industry partners. It demonstrates that a high degree of support for project management can be achieved by using a relatively small set of visualization means.

General theories explain the fundamental phenomena that constitute a research domain. They apply across a domain and often integrate many theories and concepts into a single cohesive view. While general theories are extremely important for education and research coordination, and common in many disciplines (e.g. sociology, criminology, electrical engineering, biology, physics), software engineering lacks a well-accepted general theory. The General Theory of Software Engineering workshop seeks to rectify this situation by promoting theory development in software engineering. The fourth workshop in this series, held in conjunction with the International Conference on Software Engineering, displayed a promising trend toward more theory development papers.

Continuous software engineering refers to the organizational capability to develop, release and learn from software in very short rapid cycles, typically hours, days or a very small numbers of weeks. This requires not only agile processes in teams but in the complete research and development organization. Additionally, the technology used in the different development phases, like requirements engineering and system integration, must support the quick development cycles. Finally, automatic live experimentation for different system alternatives enables fast gathering of required data for decision making. The workshop, the second in the series after the first one at ICSE 2014, aims to bring the research communities of the aforementioned areas together to exchange challenges, ideas, and solutions to bring software engineering a step further to being a holistic continuous process. The workshop program is based on eight papers selected in the peer-review process and supplemented by interaction and discussions at the workshop. The topics range from agile methods, continuous software engineering practices to specific techniques, like visualization and testing.

Current approaches to automated assessment of UML diagram mainly focus on static analysis. As this may be insufficient for behavioural diagrams, this contribution presents an approach to dynamic checks of UML Activity Diagrams. The approach makes use of trace generation and sequence alignment and shows fair results in preliminary experiments.

Programming requires both to write code and to read code. In debugging tasks, students can use supporting tools that create additional artefacts like visualizations or traces, but these again need to be read and understood. This contribution presents a concept of code reading exercises that asks students to create the same artefacts for given code as they would use for debugging their own code.

Most academic disciplines emphasize the importance of their general theories. Examples of well-known general theories include the Big Bang theory, Maxwell's equations, the theory of the cell, the theory of evolution, and the theory of demand and supply. Less known to the wider audience, but established within their respective fields, are theories with names such as the general theory of crime and the theory of marriage. Few general theories of software engineering have, however, been proposed, and none have achieved significant recognition. This workshop, organized by the SEMAT initiative, aims to provide a forum for discussing the concept of a general theory of software engineering. The topics considered include the benefits, the desired qualities, the core components and the form of a such a theory.

The new software engineering initiative, Semat, is in the process of developing a kernel for software engineering that stands on a solid theoretical basis. So far, it has suggested a set of kernel elements for software engineering and basic language constructs for defining the elements and their usage. This paper describes a session during which Semat results and status will be presented. The presentation will be followed by a discussion panel.

Automated checks for software artefacts like UML diagrams used in automated assessment or tutoring systems do often rely on direct comparisons between a solution and a sample solution. This approach has drawbacks regarding flexibility in face of different possible solutions which are quite common in modeling tasks. This paper presents an alternative technique for checking UML class diagrams based on graph queries which promises to be more flexible.

Running test cases against a student's solution of a programming assignment is one of the easiest ways to generate feedback. If black-box tests are used, students may have difficulties to retrace the complete system behaviour and to find erroneous programming statements. This paper discusses the use of automated trace generation for assisting students in this task. Both manual and automated trace interpretation is discussed and evaluated by examples.

In this paper we use formal software engineering techniques to support one of the most difficult steps in software engineering: learning to use a programming language. In order to support numerous exercises of a large number of students some automatic support for checking the solutions and providing hints for the occurrence of erroneous code fragments is highly desirable to help students doing their work. For such support a specification language to describe search patterns for typical solution patterns in student exercises has been created. This language especially supports the structured description of complex search patterns. The specified patterns are transformed into graph rules, which are applied to student solutions in our testing support environment. The approach extends the work we presented in [5]. In addition to the application areas described here the search for a class of structures can be used in other areas like the check for design patterns or looking for code fragments where refactorings can be applied.

Abstract Numerous large applications that have evolved over many years are well‐functioning and reliable, but have severe problems regarding flexibility and reuse. Due to the many fixes that were applied in a system's lifetime, it is often hard to customize, change or exchange system parts. Therefore, it is problematic to migrate such systems to a more flexible architecture or to new technologies. The document archive/retrieval system, discussed in this article, is an example of a large C system that had such problems. As a solution, we will sketch an architectural pattern language that involves patterns well‐suited for a piecemeal migration process. The patterns aim at building and composing highly flexible black‐box component architectures with an object‐oriented glueing layer. We present a re‐engineering case study for the document archive/retrieval system based on these patterns. The patterns are used to wrap the existing C implementations and integrate them with an object system. Moreover, the patterns introduce flexibility hooks into the hot spots of the architecture and let components define their required environment. This enables an easier future evolution of the system. The case study demonstrates a pattern language as an approach for piecemeal legacy migration apart from implementation details. Copyright © 2002 John Wiley & Sons, Ltd.

A major challenge in developing and coordinating distributed agents is to accommodate changes introduced at one agent and to propagate it to every other interested party. This presents a special difficulty if the information maintained in a node is highly structured. Examples of such problems are dynamic accommodation of structural changes in distributed software systems or consistency management of multiple viewpoints in typical multiple perspectives/stakeholders settings: modifications or changes not envisaged at "design time" have to be handled at run time without disturbing those parts of the system unaffected by the change. The key feature realizing such dynamic modifications and extensions is a clean separation between internal operations or actions of an individual node or agent and their structural coordination. Thus, general change rules for creation/deletion and connection/disconnection of nodes/agents can be formulated. We consider as an important problem area, dynamic change management of distributed systems. We propose to use distributed graph transformation as the underlying formalism to realize both the specification of evolving distributed systems as well as dynamic change management, thus taking a step towards building configurable distributed systems. The results obtained can easily be transferred to the field of consistency management.

Software development is a staged and evolutionary process. Multiple stakeholders with different needs and views collaborate to build a system from interoperating and heterogeneous development artifacts. In such a setting, one has to cope with requirements changing dynamically during the entire lifetime of the system. Within this changing world living with inconsistencies is natural. Tool support is needed to tolerate inconsistencies and help developers to use them to drive the development process forward. In this contribution we consider the application of distributed graph transformation to the problem of formalizing the integration of multiple perspectives in software development called ViewPoints. Our work concentrates on requirements engineering. We demonstrate how inconsistency management can be used as a tool for requirements analysis by presenting a sample integration of architecture design and performance evaluation views.

We consider the problem of detecting and handling inconsistencies in software development processes using a graph based approach. It seems to be a natural way to express the various options and possibilities in attacking the problem. We apply the techniques developed in the area of software architecture design which uses in a structured way performance models in order to produce a design which incorporates also nonfunctional requirements in terms of quantitative performance.

This paper outlines a framework which supports the use of multiple perspectives in system development, and provides a means for developing and applying systems design methods. The framework uses "viewpoints" to partition the system specification, the development method and the formal representations used to express the system specifications. This VOSE (viewpoint-oriented systems engineering) framework can be used to support the design of heterogeneous and composite systems. We illustrate the use of the framework with a small example drawn from composite system development and give an account of prototype automated tools based on the framework.