Abstract The more critical infrastructures (CIs) being digitized, the more vulnerable they are regarding cyber security attacks. Digitisation-leveraging technologies in the Internet of Things (IoT) and Cyber-Physical Systems (CPS) have been largely adopted for CIs, along with the Digital Twin (DT) paradigm. However, the distributed and heterogeneous nature of IoT or CPS poses significant challenges in safeguarding against diverse attack surfaces, including physical devices, network infrastructures, and third-party integration. To tackle these challenges, we propose an AI-driven DT-based security orchestration automation and response framework (SOAR4BC). Gathering system contexts from the DT in combination with security intelligence from the security tools gives us a holistic context for SOAR, which has not been seen in the existing approaches. We leverage this holistic context into the decision-making core, which utilizes advanced algorithms, like deep reinforcement learning, to generate adaptation recommendations based on incident alerts, risk assessments, and system state observations. By rigorously evaluating tampered data and distributed denial of service (DDoS) scenarios, we validate the SOAR4BC framework’s efficacy in handling security incidents leveraging digital twin environments. We further demonstrate real-world applicability through false-data injection and DoS attacks on an operational electric-vehicle charging testbed, confirming the practical effectiveness of SOAR4BC in securing critical infrastructures. Together, these results establish SOAR4BC as a robust and explainable AI-driven SOAR framework that advances the use of digital twins for cybersecurity in IoT and CPS ecosystems, offering actionable contributions for both research and industrial deployment.

Just-in-time defect prediction (JIT DP) leverages machine learning to identify defect-prone code commits, enabling quality assurance (QA) teams to allocate resources more efficiently by focusing on commits that are most likely to contain defects. Although JIT defect prediction techniques have introduced notable improvements in terms of predictive accuracy, they are still susceptible to misclassification errors such as false positives and false negatives. To preserve the practical utility of JIT defect prediction tools, it becomes essential to estimate the reliability of the predictions, i.e., computing confidence scores. Such scores can help practitioners identify predictions that are most likely to be correct. A simple approach to computing confidence scores is to extract, alongside each prediction, the corresponding prediction probabilities and use them as indicators of confidence. However, for these probabilities to reliably serve as confidence scores, the predictive model must be well-calibrated. This means that the prediction probabilities must accurately represent the true likelihood of each prediction being correct. Miscalibration, common in modern machine learning models, distorts probability scores such that the model’s prediction probabilities do not align with the actual probability of those predictions being correct. Despite its importance, model calibration has been largely overlooked in JIT defect prediction. In this study, we evaluate the calibration of several state-of-theart JIT defect prediction techniques to determine whether and to what extent they exhibit poor calibration. Furthermore, we assess whether post-calibration methods can improve the calibration of existing JIT defect prediction models. Our experimental analysis reveals that all evaluated JIT DP models exhibit some level of miscalibration, with Expected Calibration Error (ECE) ranging from 2% to 35%. Furthermore, post-calibration methods do not consistently improve the calibration of these JIT DP models. Index Terms-Just-in-time defect prediction, machine learning, model calibration, prediction probabilities, prediction reliability.

Code changes can introduce defects that affect software quality and reliability. Just-in-time (JIT) defect prediction techniques provide feedback at check-in time on whether a code change is likely to contain defects. This immediate feedback allows practitioners to make timely decisions regarding potential defects. However, a prediction model may deliver false predictions, that may negatively affect practitioners' decisions. False positive predictions lead to unnecessarily spending resources on investigating clean code changes, while false negative predictions may result in overlooking defective changes. Knowing how uncertain a defect prediction is, would help practitioners to avoid wrong decisions. Previous research in defect prediction explored different approaches to quantify prediction uncertainty for supporting decision-making activities. However, these approaches only offer a heuristic quantification of uncertainty and do not provide guarantees.

Online reinforcement learning (RL) is increasingly used for realizing adaptive systems in the presence of design time uncertainty because Online RL can leverage data only available at run time. With Deep RL gaining interest, the learned knowledge is no longer represented explicitly but hidden in the parameterization of the underlying artificial neural network. For a human, it thus becomes practically impossible to understand the decision-making of Deep RL, which makes it difficult for (1) software engineers to perform debugging, (2) system providers to comply with relevant legal frameworks, and (3) system users to build trust. The explainable RL technique XRL-DINE, introduced in earlier work, provides insights into why certain decisions were made at important time steps. Here, we perform an empirical user study concerning XRL-DINE involving 73 software engineers split into treatment and control groups. The treatment group is given access to XRL-DINE, while the control group is not. We analyze (1) the participants’ performance in answering concrete questions related to the decision-making of Deep RL, (2) the participants’ self-assessed confidence in giving the right answers, (3) the perceived usefulness and ease of use of XRL-DINE, and (4) the concrete usage of the XRL-DINE dashboard.

Solana has quickly emerged as a popular platform for building decentralized applications (DApps), such as marketplaces for non-fungible tokens (NFTs). A key reason for its success are Solana's low transaction fees and high performance, which is achieved in part due to its stateless programming model. Although the literature features extensive tooling support for smart contract security, current solutions are largely tailored for the Ethereum Virtual Machine. Unfortunately, the very stateless nature of Solana's execution environment introduces novel attack patterns specific to Solana requiring a rethinking for building vulnerability analysis methods.

An edge data center can host applications that require low-latency access to nearby end devices. If the resource requirements of the applications exceed the capacity of the edge data center, some non-latency-critical application components may be offloaded to the cloud. Such offloading may incur financial costs both for the use of cloud resources and for data transfer between the edge data center and the cloud. Moreover, such offloading may violate data protection requirements if components process sensitive data. The operator of the edge data center has to decide which components to keep in the edge data center and which ones to offload to the cloud. In this paper, we formalize this problem and prove that it is strongly NP-hard. We introduce an optimization algorithm that is fast enough to be run online for dynamic and automatic offloading decisions, guarantees that the solution satisfies hard constraints regarding latency, data protection, and capacity, and achieves near-optimal costs. We also show how the algorithm can be extended to handle multiple edge data centers. Experiments show that the cost of the solution found by our algorithm is on average only 2.7% higher than the optimum.

Edge computing enables the processing of data - frequently personal data - at the edge of the network. For personal data, legislation such as the European General Data Protection Regulation requires data protection by design. Hence, data protection has to be accounted for in the design of edge computing systems whenever personal data is involved. This leads to specific requirements for modeling the architecture of edge computing systems, e.g., representation of data and network properties. To the best of our knowledge, no existing modeling language fulfils all these requirements. In our previous work we showed that the commonly used UML profile UMLsec fulfils some of these requirements, and can thus serve as a starting point. The aim of this paper is to create a modeling language which meets all requirements concerning the design of the architecture of edge computing systems accounting for data protection. Thus, we extend UMLsec to satisfy all requirements. We call the resulting UML profile UMLsec4Edge. We follow a systematic approach to develop UMLsec4Edge. We app UMLsec4Edge to real-world use cases from different domains, and create appropriate deployment diagrams and class diagrams. These diagrams show UMLsec4Edge is capable of meeting the requirements.

Abstract Proactive process adaptation can prevent and mitigate upcoming problems during process execution. Proactive adaptation decisions are based on predictions about how an ongoing process instance will unfold up to its completion. On the one hand, these predictions must have high accuracy, as, for instance, false negative predictions mean that necessary adaptations are missed. On the other hand, these predictions should be produced early during process execution, as this leaves more time for adaptations, which typically have non-negligible latencies. However, there is an important tradeoff between prediction accuracy and earliness. Later predictions typically have a higher accuracy, because more information about the ongoing process instance is available. To address this tradeoff, we use an ensemble of deep learning models that can produce predictions at arbitrary points during process execution and that provides reliability estimates for each prediction. We use these reliability estimates to dynamically determine the earliest prediction with sufficient accuracy, which is used as basis for proactive adaptation. Experimental results indicate that our dynamic approach may offer cost savings of 27% on average when compared to using a static prediction point.

Complex Event Processing (CEP) facilitates monitoring large-scale, distributed systems. CEP applications analyze real-time streams of events to detect patterns that indicate problems that may require an adaptation of the running system. Like for any software system, developers may introduce faults when designing and implementing CEP applications. Such faults may imply that true problems may not be detected during systems operation, or false alarms may be raised even though no problem exists. Therefore, verifying the CEP application during design time is critical to ensure correct system monitoring at run-time. To address the scalability problem of verifying CEP applications, we propose an incremental verification approach building on recent advances in model checking. Results of an initial evaluation indicate under which assumptions our approach scales better than standard model checking.

Educational approaches for computer science proposing the use of complete online courses or traditional courses employing some kind of online material have received much attention recently. The integration of online materials into traditional courses or the replacement of entire courses offer huge possibilities, including increased teaching quality and better study and work alignment. However, researchers and teachers also identified some drawbacks of using online material, including the lack of interaction between students and teachers, and the need to discuss and provide feedback of the students' exercise results. A solution for providing such feedback are automated assessment tools which can generate feedback. However, these tools are not applicable in all situations, e.g. for providing feedback to conceptual modeling exercises. In this paper, we report on the design and implementation of an online course for teaching conceptual modeling. In this course, we use explicitly ambiguous exercises and sketch multiple solutions in brief whiteboard-style videos, thus enabling students to assess their own solutions. Evaluation results show that the proposed approach is able to fulfill students' educational needs.

A significant challenge within university education, especially with regard to the teaching of highly theoretical topics like requirements engineering, is to maintain students' interest and motivation whilst addressing the core concepts that will enable students to work in industry upon graduation. It has long been established that experience-based learning can aid in both these feats: On the one hand, providing students with industrial case examples rather than "dry" academic assignments can increase student interest and motivation. On the other hand, a case example-centric classroom approach can yield a rich learning environment which fosters collaboration, communication, and self-directed exploration of the instructed principles. In previous work, we have reported on our experience in changing a graduate requirements engineering course towards using case examples based on real industry projects. As more and more curricula change in advance of project-based teaching paradigms, this paper discusses results from the long-term application of such a course design in a graduate setting. In addition, this paper reports our findings from the replication in an undergraduate requirements engineering course indicating that project-based learning techniques foster different teaching goals in graduate and undergraduate settings.

In empirical software engineering research, graduate students are often seen as legitimate substitutes for industry professionals. It has been also argued in the literature that the generalizability of empirical results from experiments with undergraduate students as participants holds to a much lower extent. In this paper, we report on a controlled experiment conducted separately with graduate students and undergraduate students in order to gain deeper insights whether the results from experiments with graduates and undergraduates in the software engineering field are equal or significantly different with respect to the conclusions that can be drawn. During the experiment, the students apply a specific validation technique for behavioral requirements of embedded software. We observed that graduates were significantly more effective, efficient, and confident in their tasks than the undergraduates. Nevertheless, the experiment with undergraduates also shows significant results, even though with a smaller effect size.

Transport and logistics faces fluctuations in cargo volume that statistically can only be captured with a large error. Observing and managing such dynamic volume fluctuations more effectively promises many benefits such as reducing unused transport capacity and ensuring timely delivery of cargo. This paper introduces an approach that combines user-friendly mobile devices with internet-connected sensors to deliver up-to-date, timely, and precise information about parcel volumes inside containers. In particular, we present (1) RCM, a mobile app for unique identification of containers, and (2) SNAP, a novel approach for employing internet-connected low-cost, off-the-shelf 3D scanners for capturing and analyzing actual cargo volumes. We have evaluated the accuracy of SNAP in controlled experiments indicating that cargo volume can be measured with high accuracy. We have further evaluated RCM together with SNAP by means of a survey study with domain experts, revealing its high potential for practical use.

Predictive business process monitoring aims at forecasting potential problems during process execution before they occur so that these problems can be handled proactively. Several predictive monitoring techniques have been proposed in the past. However, so far those prediction techniques have been assessed only independently from each other, making it hard to reliably compare their applicability and accuracy. We empirically analyze and compare three main classes of predictive monitoring techniques, which are based on machine learning, constraint satisfaction, and Quality-of-Service (QoS) aggregation. Based on empirical evidence from an industrial case study in the area of transport and logistics, we assess those techniques with respect to five accuracy indicators. We further determine the dependency of accuracy on the point in time during process execution when a prediction is made in order to determine lead-times for accurate predictions. Our evidence suggests that, given a lead-time of half of the process duration, all predictive monitoring techniques consistently provide an accuracy of at least 70%. Yet, it also becomes evident that the techniques differ in terms of how accurately they may predict violations and nonviolations. To improve the prediction process, we thus exploit the characteristics of the individual techniques and propose their combination. Based on our case study data, evidence indicates that certain combinations of techniques may outperform individual techniques with respect to specific accuracy indicators. Combining constraint satisfaction with QoS aggregation, for instance, improves precision by 14%; combining machine learning with constraint satisfaction shows an improvement in recall by 23%.

University education in software engineering instructs sound theoretical concepts together with method competence. It seeks to provide hands-on experience with the learning content along with insights into its application in practice. Even theoretical disciplines are beginning to adopt more experience-oriented instruction as opposed to passive, lecture-oriented instruction. One favored way for experience-oriented instructions is using case studies in lecture-accompanying assignments and/or tutorials. Compared with real-world scenarios, such case studies are often simplified in order to illustrate specific challenges related to the instructed material. This paper reports on our experience in using realistic industry-oriented case studies in a requirements engineering course with graduate students. The experience indicates a strong positive effect on student motivation as well as the degree of comprehension of the instructed theoretical material. These findings are confirmed by evaluations of the learning experience as self-reported through students' questionnaires. Comparing the exam results with previous years indicates substantial improvement in final exam scores.

The transition to cloud computing offers a large number of benefits, such as lower capital costs and a highly agile environment. Yet, the development of software engineering practices has not kept pace with this change. Moreover, the design and runtime behavior of cloud based services and the underlying cloud infrastructure are largely decoupled from one another.This paper describes the innovative concepts being developed by CloudWave to utilize the principles of DevOps to create an execution analytics cloud infrastructure where, through the use of programmable monitoring and online data abstraction, much more relevant information for the optimization of the ecosystem is obtained. Required optimizations are subsequently negotiated between the applications and the cloud infrastructure to obtain coordinated adaption of the ecosystem. Additionally, the project is developing the technology for a Feedback Driven Development Standard Development Kit which will utilize the data gathered through execution analytics to supply developers with a powerful mechanism to shorten application development cycles.

In the embedded systems industry, function-centered engineering is commonly applied to address the increasing number and complexity of system functions. During function-centered engineering, the functional design that is created based on the defined requirements for the system is the main artifact that serves as a basis for subsequent development activities. If stakeholder intentions change and modifications become necessary, they are frequently incorporated directly into the functional design without updating the behavioral requirements accordingly. As a consequence, the correctness of the interplay of system functions as defined in the functional design cannot be assessed by checking it against the defined requirements (since they are outdated) but needs to be checked against the current stakeholder intentions. More precisely, the requirements engineer has to validate the functional design against the stakeholder intentions because he is the expert concerning the stakeholder intentions and can communicate with the stakeholders regarding them, if necessary. However, the requirements engineer is typically not familiar with the functional design and its notation on the one hand, and, on the other hand, the overall behavior of the system is spread across various diagrams in the functional design. Therefore, the requirements engineer needs a more abstract and consolidated view of the functional design in order to be able to validate its correctness with regard to the current stakeholder intentions. In this paper, we present an approach which is based on a specific kind of review model that is automatically generated from the functional design and supports the requirements engineer in her task. The approach that is presented in this paper is subject of ongoing research.

The automated analysis of feature models (FM) is based on SAT, BDD, and CSP - known NP-complete problems. Therefore, the analysis could have an exponential worst-case execution time. However, for many practical relevant analysis cases, state-of-the-art (SOTA) analysis tools quite successfully master the problem of exponential worst-case execution time based on heuristics. So far, however, very little is known about the structure of FMs that cause the cases in which the execution time (hardness) for analyzing a given FM increases unpredictably for SOTA analysis tools. In this paper, we propose to use width measures from graph theory to characterize the structural complexity of FMs as a basis for an estimation of the hardness of analysis operations on FMs with SOTA analysis tools. We present an experiment that we use to analyze the reasonability of graph width measures as metric for the structural complexity of FMs and the hardness of FM analysis. Such a complexity metric can be used as a basis for a unified method to systematically improve SOTA analysis tools.

The internet of services (IoS) and the internet of things (IoT) will significantly change the engineering and operation of future information systems and the economy as a whole. The convergence of IoS and IoT empowers new types of software-intensive systems which, among others, facilitate real-time observation and adaptation of intra and cross organizational processes.

Increasingly, service-based applications (SBAs) are composed of third-party services available over the Internet. Even if third-party services have shown to work during design-time, they might fail during the operation of the SBA due to changes in their implementation, provisioning, or the communication infrastructure. As a consequence, SBAs need to dynamically adapt to such failures during run-time to ensure that they maintain their expected functionality and quality. Ideally the need for an adaptation is proactively identified, i.e., failures are predicted before they can lead to consequences such as costly compensation and roll-back activities. Currently, approaches to predict failures are based on monitoring. Due to its passive nature, however, monitoring might not cover all relevant service executions, which can diminish the ability to correctly predict failures. In this paper we demonstrate how online testing, as an active approach, can improve failure prediction by considering a broader range of service executions. Specifically, we introduce a framework and prototypical implementation that exploits synergies between monitoring, online testing and quality prediction. For online test selection and assessment we adapt usage-based testing strategies. We experimentally evaluate the strengths of our approach in predicting the need for an adaptation of an SBA.

The formalization of variability models (e.g. feature models) is a prerequisite for the automated analysis of these models. The efficient execution of the analysis operations depends on the selection of well-suited solver implementations. Regarding feature models, on the one hand, the formalization with Boolean expressions enables the use of SAT or BDD solvers. On the other hand, feature models can be transformed into a Constraint-Satisfaction Problem (CSP) in order to use CSP solvers for validation. This paper presents a performance comparison regarding nine contemporary high-performance solvers, three for each base problem structure (BDD, CSP, and SAT). Four operations on 90 feature models are run on each solver. The results will in turn clear the way for new improvements regarding the automatic verification of software product lines, since the efficient execution of analysis operations is essential to such automatic verification approaches.

In product line engineering individual products are derived from the domain artifacts of the product line. The reuse of the domain artifacts is constraint by the product line variability. Since domain artifacts are reused in several products, product line engineering benefits from the verification of domain artifacts. For verifying development artifacts, model checking is a well-established technique in single system development. However, existing model checking approaches do not incorporate the product line variability and are hence of limited use for verifying domain artifacts. In this paper we present an extended model checking approach which takes the product line variability into account when verifying domain artifacts. Our approach is thus able to verify that every permissible product (specified with I/O-automata) which can be derived from the product line fulfills the specified properties (specified with CTL). Moreover, we use two examples to validate the applicability of our approach and report on the preliminary validation results.

The domain requirements specification (DRS) of a product line comprises the common and variable requirements of all products of the product line. Due to the variability defined for a product line, the DRS may contain contradicting requirements. For example, it may contain requirements A and not(A) which can be included in different products. Checking the consistency of DRS in product line engineering is thus not straightforward. Variability information has to be incorporated into the consistency checks to ensure that contradicting requirements do not become part of the same product requirements specification. In this paper, we present a consistency checking technique for dynamic properties of DRS based on model checking techniques. We present a proof of correctness for the technique, sketch our tool environment, and report on the application of the approach to an industrial example.

A requirements specification for an individual software system should be consistent, i.e. free of contradictions. In product line engineering, the product line requirements specification comprises all the requirements common to all products of the product line as well as the variable requirements used to derive individual products from the product line. The set of requirements (common and all the variable ones) of a product line is typically inconsistent since variable requirements can contradict each other. This is not a problem as long as contradicting requirements are not included in a product derived from the product line. Thus, the set of requirements realized in each individual product has to be consistent. Employing techniques used in single system development to check the consistency of product line requirements will thus produce false positive results, since there can be contradiction in the product line requirements specification In this paper we first provide a concise definition of consistency for product line requirements specifications. Based on this definition, we define a formal framework for checking consistency of product line requirements specifications. Our framework supports consistency checks in the domain engineering process. In contrast to consistency checks in single system development, it tolerates certain types of inconsistencies caused by the variability of prod-uct line requirements.

Feature diagrams are a popular means for documenting variability in software product line engineering. When examining feature diagrams in the literature and from industry, we observed that the same modelling concepts are used for documenting two different kinds of variability: (1) product line variability, which reflects decisions of product management on how the systems that belong to the product line should vary, and (2) software variability, which reflects the ability of the reusable product line artefacts to be customized or configured. To disambiguate the documentation of variability, we follow previous suggestions to relate orthogonal variability models (OVMs) to feature diagrams. This paper reuses an existing formalization of feature diagrams, but introduces a formalization of OVMs. Then, the relationships between the two kinds of models are formalized as well. Besides a precise definition of the languages and the links, the important benefit of this formalization is that it serves as a foundation for a tool supporting automated reasoning on variability. This tool can, e.g., analyse whether the product line artefacts are flexible enough to build all the systems that should belong to the product line.

The need for co-designing requirements and architecture for innovative software-intensive systems is widely accepted. In this paper, we present the key ideas of our method COSMOD-RE for supporting the co-design of requirements and architectural artifacts. The backbone of COSMOD-RE is a hierarchy of four abstraction layers. At each layer, a requirements viewpoint and an architectural viewpoint are co-developed and aligned using a goal- and scenario-based approach. COSMOD-RE defines three co-design processes and five sub-processes for each co-design process to structure and guide the co-development.

By explicitly modeling and managing variability, software product line engineering provides a systematic approach for creating a diversity of similar products at low cost, in short time, and with high quality. This tutorial focuses on the two principle differences of software product line engineering when compared to single systems development: The differentiation of two key development processes (domain engineering and application engineering) and the explicit representation and management of variability. We characterize the two processes and their main activities and introduce the orthogonal variability modeling approach (OVM). We further illustrate the OVM approach in the product line requirements engineering and product line testing activities.

Software product line engineering (SPLE) is the approach for creating a diversity of similar products at low cost, in short time, and with high quality. Explicitly documenting product line variability is essential for variability management as it significantly supports the following activities: Defining the commonality and the variability of the product line during domain engineering; Realizing reusable artifacts (the domain artifacts) with variability; Defining the binding of variability during application engineering; Deriving individual applications by exploiting the variability in the domain artifacts. This tutorial is based on our text book on software product line engineering [1]. The tutorial is structured along an SPLE framework, which has been defined based on our experiences and the results of the European software product line research projects ESAPS, CAFÉ, and FAMILIES [2].

It is our great pleasure to welcome you to the Experience Reports Track of the 27th International Conference on Software Engineering (ICSE). The objective of the Experience Reports Track is to establish a dialogue between software practitioners and software engineering researchers on the benefits, obstacles, and weaknesses of applying software engineering principles, techniques, methods, processes, and tools in an industrial or organizational setting. In the call for papers, we invited four types of submissions: case studies, experience reports, experimental reports and problem statements. The call attracted 72 submissions from all over the world. The program committee of the Experience Reports Track accepted 14 submissions. The selection was based on at least three reviews per submission and the results of intensive consensus discussions prior to and during the Experience Reports Track program committee meeting, held on November 12, 2004 in Essen, Germany.The accepted papers of the ICSE 2005 Experience Reports Track cover topics such as agile methods, product lines, requirements engineering, software architecture, testing and verification. They document important lessons learned from applying software engineering principles, techniques, methods, processes, and tools in practice. Putting together the Experience Reports Track of ICSE 2005 was a team effort. We extend our sincerest gratitude to all of the people who helped us shape this event, especially to the members of our program committee and the ICSE 2005 organizing committee and to Richard van de Stadt, Andreas Metzger, and Nelufar Ulfat-Bunyadi. We hope that you find the Experience Reports Track of ICSE 2005 interesting and thought-provoking.

The explicit definition of variability in software product lines is a key difference between the development of single software systems and software product line engineering. More and more companies maintain several software product lines which focus on different types of products, market segments, and/or domains. Those product lines typically share commonalities and variability. The companies thus face the problem of managing communality and variability across different product lines. In this paper, we identify essential requirements for the documentation of requirements variability across product lines. We propose a meta model for structuring the variability information, sketch a prototypical realisation for managing variability across product lines in DOORS, and illustrate the use of the meta model in a small example. We further report on experiences made with the proposed variability modelling approach.

When specifying change for an existing system, the history and functionality of the system to be replaced has to be considered. This avoids neglecting important system functionality and repeating errors. The properties and the rationale behind the existing system can be elicited by analysing concrete system-usage scenarios [Pohl, K., Weidenhaupt, K., Dömges, R., Haumer, P., Jarke, M., Klamma, R., 1999. Process-integrated (modelling) environments (PRIME): foundation and implementation framework. ACM Transactions on Software Engineering and Methodology (TOSEM), vol. 8, no. 4, pp. 343–410]. The results of the analysis of the existing system are then typically represented using conceptual models. To establish conceptual models of high quality reviewing the models is common practice. The problem faced with when reviewing conceptual models, is that the reviewer cannot assess and therefore understand the basis (concrete system usage) on which the conceptual models were built. In this paper, we present an approach to overcome this problem. We establish Extended Traceability, by recording concrete system-usage scenarios using rich media (e.g. video, speech, graphic) and interrelating the recorded observations with the conceptual models. We discuss the main improvements for review processes and illustrate the advantages with excerpts from a case study performed in a mechanical engineering company.

Requirements engineering (RE) investigates the impact of a future-oriented change vision, but the move towards this vision must consider a context heavily shaped by the past. As RE becomes a continuous process throughout the system lifecycle, it must achieve an effective combination of envisionment and traceability. We describe a scenario-based solution to this problem which is based on an integration of five ingredients: the persistent capture of context in the form of real world scenes captured in multimedia; formal agent-oriented modelling with a semantics that allows distributed interactive animation; message trace diagrams as a medium for exchanging animation test cases and traces; a goal model to control and record the RE process; and a process-integrated tool environment to ensure method-guidance and traceability with as little effort as possible. In addition to the basics of our approach, we also describe its prototypical implementation in the CREWS-EVE environment and demonstrate its usefulness with examples from a case study in the production industry.

Research in process-centered environments (PCEs) has focused on project management support and has neglected method guidance for the engineers performing the (software) engineering process. It has been dominated by the search for suitable process-modeling languages and enactment mechanisms. The consequences of process orientation on the computer-based engineering environments, i.e., the interactive tools used during process performance, have been studied much less. In this article, we present the PRIME (Process Integrated Modeling Environments) framework which empowers method guidance through process-integrated tools. In contrast to the tools of PCEs, the process-integrated tools of PRIME adjust their behavior according to the current process situation and the method definitions. Process integration of PRIME tools is achieved through (1) the definition of tool models; (2) the integration of the tool models and the method definitions; (3) the interpretation of the integrated environment model by the tools, the process-aware control integration mechanism, and the enactment mechanism; and (4) the synchronization of the tools and the enactment mechanism based on a comprehensive interaction protocol. We sketch the implementation of PRIME as a reusable implementation framework which facilitates the realization of process-integrated tools as well as the process integration of external tools. We define a six-step procedure for building a PRIME-based process-integrated environment (PIE) and illustrate how PRIME facilitates change integration on an easy-to-adapt modeling level.

A requirements specification defines the requirements for the future system at a conceptual level (i.e., class or type level). In contrast, a scenario represents a concrete example of current or future system usage. In early RE phases, scenarios are used to support the definition of high level requirements (goals) to be achieved by the new system. In many cases, those goals can to a large degree be elicited by observing, documenting and analyzing scenarios about current system usage. To support the elicitation and validation of the goals achieved by the existing system and to illustrate problems of the old system, we propose to capture current system usage using rich media (e.g., video, speech, pictures, etc.) and to interrelate those observations with the goal definitions. Thus, we aim at making the abstraction process which leads to the definition of the conceptual models more transparent and traceable. We relate the parts of the observations which have caused the definition of a goal or against which a goal was validated with the corresponding goal. These interrelations provide the basis for: 1) explaining and illustrating a goal model to, e.g., untrained stakeholders and/or new team members; 2) detecting, analyzing, and resolving a different interpretation of the observations; 3) comparing different observations using computed goal annotations; and 4) refining or detailing a goal model during later process phases. Using the PRIME implementation framework, we have implemented the PRIME-CREWS environment, which supports the interrelation of conceptual models and captured system usage observations. We report on our experiences with PRIME-CREWS gained in an experimental case study.