In safety-critical engineering domains, engineering processes guide developers toward producing systems that adhere to stringent standards of safety and quality, while also allowing for the inherent flexibility of creative tasks. Process compliance focuses on ensuring that the engineering work-as manifested in the creation, tracking, and tracing of engineering artifacts-follows the described processes as closely as possible. The sequence of process steps is typically described using temporal process constraints over engineering artifact metadata (e.g., a requirement must transition from ‘draft’ to ‘ready for review’). Existing approaches, however, lack support for checking temporal constraints during development and rely on manual checks, resulting in delayed feedback when deviations occur. In this paper, we present an automated, incremental constraint checking approach that can evaluate temporal constraints across inter-related artifacts upon every artifact change, enabling timely feedback on process deviations. Our approach includes an incremental checking mechanism for temporal process constraints, and the ability to dynamically evaluate and integrate the history of artifacts as they become relevant for the constraints. Temporal constraints are expressed in the Object Constraint Language (OCL) extended with operators from Linear Temporal Logic (LTL). We demonstrate the ability of our approach to support a wide range of higher-level temporal patterns. We show that for constraints in an industry-derived use case, we can detect a significant number of temporal process constraint violations, some remaining unfulfilled after the end of the development process. We also find that, in this use case, the average evaluation for a single constraint operator takes around 0.3 milliseconds.

Just-in-time defect prediction (JIT-DP) aims to predict the likelihood of code changes resulting in software defects at an early stage. Although code change metrics and semantic features have enhanced prediction accuracy, prior research has largely ignored code refactoring during both the evaluation and methodology phases, despite its prevalence. Refactoring and its propagation often tangle with bug-fixing and bug-inducing changes within the same commit and statement. Neglecting refactoring can introduce bias into the learning and evaluation of JIT-DP models. To address this gap, we investigate the impact of refactoring and its propagation on six state-of-the-art JIT-DP approaches. We propose Code chAnge Tactics (CAT) analysis to categorize code refactoring and its propagation, which improves labeling accuracy in the JIT-Defects4J dataset by $\mathbf{1 3. 7}$. Our experiments reveal that failing to consider refactoring information in the dataset can diminish the performance of models, particularly semantic-based models, by $\mathbf{1 8. 6}$ % and $\mathbf{3 7. 3} \%$ in F1-score. Additionally, we propose integrating refactoring information to enhance six baseline approaches, resulting in overall improvements in recall and $\mathbf{F 1}$-score, with increases of up to $43.2 \%$ and $32.5 \%$, respectively. Our research underscores the importance of incorporating refactoring information in the methodology and evaluation of JIT-DP. Furthermore, our CAT has broad applicability in analyzing refactoring and its propagation for software maintenance.

Abstract In safety‐critical systems engineering, regulations such as Automotive SPICE, ISO26262, or ED‐109A mandate software quality assurance measures to provide evidence that the developed system is high quality. The constraints that define quality assurance conditions during the engineering life cycle are often non‐trivial. This paper addresses the challenges, engineers face who are unfamiliar with the precise constraints of various projects (e.g., when newly joining a company or switching between departments). Understanding how to fulfill a constraint is a time‐consuming and challenging task as an engineer needs to determine the most suitable option (out of potentially many) to fulfill a constraint violation. To this end, we propose a guidance action ranking framework to provide engineers with the most relevant guidance actions. Our primary ranking algorithm analyzes in the background the actions that engineers have made in the past to resolve a constraint violation without requiring explicit feedback from them. We evaluated our framework on two real‐world data sets: an open‐source drone management and an industrial air traffic control software system. Concretely, we replay past engineering activities and measured whether, in the case of a constraint violation, our suggested guidance actions were indeed selected by the engineer. The evaluation results revealed that learning from prior guidance actions effectively identifies the most appropriate guidance actions (ranked top 1 or 2) when compared to ranking algorithms based on action simplicity and artifact property change frequency. Specifically, we achieve a median MRR of 0.95 for the first case study and 0.94 for the second case study: an improvement of 80% and 100% over the baseline. Additionally, we observed that the simplicity of a guidance action does not reliably indicate its suitability for fulfilling a constraint, whereas learning from prior change operation property out‐performed simplicity‐based ranking but did not surpass guidance frequency‐based ranking.

ABSTRACT This paper addresses the challenge of automating process‐centric quality assurance (QA) in safety‐critical domains, where compliance with regulations is crucial. Currently, QA engineers manually check compliance using tedious methods like browsing engineering artifacts and ad‐hoc scripts. Automated support could improve efficiency, but it requires constraints to be written in structured, executable forms (e.g., in the Object Constraint Language, OCL), whereas engineers prefer natural language. To bridge this gap, we propose the use of large language models (LLMs) to generate OCL from natural language, enhanced by schema‐based prompting and domain‐specific language (DSL)–based repairs. Unlike prior work focused on UML models, this work applies OCL to software process QA. Evaluating six LLMs, we find o1‐mini and Codestral perform best, with our automatic repairs ensuring constraint executability for 22%–44% of an LLM's generated OCL constraints that would otherwise remain nonexecutable due to errors.

Traceability allows stakeholders to extract and comprehend the trace links among software artifacts introduced across the software life cycle, to provide significant support for software engineering tasks. Despite its proven benefits, software traceability is challenging to recover and maintain manually. Hence, plenty of approaches for automated traceability have been proposed. Most rely on textual similarities among software artifacts, such as those based on Information Retrieval (IR). However, artifacts in different abstraction levels usually have different textual descriptions, which can greatly hinder the performance of IR-based approaches (e.g., a requirement in natural language may have a small textual similarity to a Java class). In this work, we leverage the consensual biterms and transitive relationships (i.e., inner- and outer-transitive links) based on intermediate artifacts to improve IR-based traceability recovery. We first extract and filter biterms from all source, intermediate, and target artifacts. We then use the consensual biterms from the intermediate artifacts to enrich the texts of both source and target artifacts, and finally deduce outer and inner-transitive links to adjust text similarities between source and target artifacts. We conducted a comprehensive empirical evaluation based on five systems widely used in other literature to show that our approach can outperform four state-of-the-art approaches in Average Precision over 15% and Mean Average Precision over 10% on average.

In regulation-intensive domains, software engineering organizations need to demonstrate compliance with process and traceability guidelines. To this end, novel approaches have emerged that support these activities via the automatic checking of constraints. Yet, engineers still need to decide how to fix violated constraints. While some general-purpose state-of-the-art constraint-checking approaches provide basic support for fixing constraint violations, the provided fixing recommendations often lack crucial details. The approaches typically do not analyze the overall constraint to identify which constraint sub-expressions put a restriction on the possible fixing action. For example, a fix suggests “set the parent of requirement R1 to an issue” rather than additionally stating that the “issue needs to be of type ’Change Request’ and in state ’Released” ’. Engineers, therefore, require mental effort to identify such restrictions by analyzing the constraint in detail or require extra time to try out which action completely fixes the constraint violation.

Refining high-level requirements into low-level ones is a common task, especially in safety-critical systems engineering. The objective is to describe every important aspect of the high-level requirement in a low-level requirement, ensuring a complete and correct implementation of the system's features. To this end, standards and regulations for safety-critical systems require reviewing the coverage of high-level requirements by all its low-level requirements to ensure no missing aspects.

Software engineering organizations in safety-critical domains require rigorous processes that include explicit software quality assurance measures (QA) to achieve high-quality and safe engineering artifacts. One major challenge for engineers is adhering to the correct process that is applicable in their specific working context, to understand which steps are ready to start, what actions are missing to complete their step, and when rework has happened. In this paper, we propose and evaluate ProGuide, a framework that provides actionable, light-weight process guidance by continuously assessing pre-conditions, post-conditions, and QA constraints. In case of a violation, it provides concrete repair actions. Evaluation on a safety-critical open source system and engineers from our industry partner Bosch showed that repairs are complete and small in number, and resulted in less frustration and fewer mistakes compared to being provided with no process guidance. Editor’s note: Open Science material was validated by the Journal of Systems and Software Open Science Board.

Summary In software development, developer turnover is among the primary reasons for project failures, leading to a great void of knowledge and strain for newcomers. Unfortunately, no established methods exist to measure how the problem domain knowledge is distributed among developers. Awareness of how this knowledge evolves and is owned by key developers in a project helps stakeholders reduce risks caused by turnover. To this end, this paper introduces a novel, realistic representation of problem domain knowledge distribution: the ConceptRealm. To construct the ConceptRealm, we employ a latent Dirichlet allocation model to represent textual features obtained from 300 K issues and 1.3 M comments from 518 open‐source projects. We analyze whether the newly emerged issues and developers share similar concepts or how aligned the individual developers' concepts are with the team over time. We also investigate the impact of leaving developers on the frequency of concepts. Finally, we also evaluate the soundness of our approach on a closed‐source software project, thus allowing the validation of the results from a practical standpoint. We find out that the ConceptRealm can represent the problem domain knowledge within a project and can be utilized to predict the alignment of developers with issues. We also observe that projects exhibit many keepers independent of project maturity and that abruptly leaving keepers correlates with a decline of their core concepts as the remaining developers cannot quickly familiarize themselves with those concepts.

A large number of bug reports are created during the evolution of a software system. Locating the source code files that need to be changed in order to fix these bugs is a challenging task. Information retrieval-based bug localization techniques do so by correlating bug reports with historical information about the source code (e.g., previously resolved bug reports, commit logs). These techniques have shown to be efficient and easy to use. However, one flaw that is nearly omnipresent in all these techniques is that they ignore code refactorings. Code refactorings are common during software system evolution, but from the perspective of typical version control systems, they break the code history. For example, a class when renamed then appears as two separate classes with separate histories. Obviously, this is a problem that affects any technique that leverages code history. This paper proposes a refactoring-aware traceability model to keep track of the code evolution history. With this model, we reconstruct the code history by analyzing the impact of code refactorings to correctly stitch together what would otherwise be a fragmented history. To demonstrate that a refactoring aware history is indeed beneficial, we investigated three widely adopted bug localization techniques that make use of code history, which are important components in existing approaches. Our evaluation on 11 open source projects shows that taking code refactorings into account significantly improves the results of these bug localization techniques without significant changes to the techniques themselves. The more refactorings are used in a project, the stronger the benefit we observed. Based on our findings, we believe that much of the state of the art leveraging code history should benefit from our work.

Bug localization is the task of recommending source code locations (typically files) that probably contain the cause of a bug and hence need to be changed to fix the bug. Along these lines, information retrieval-based bug localization (IRBL) approaches have been adopted, which identify the most bug-prone files from the source code space. In current practice, a series of state-of-the-art IRBL techniques leverage the combination of different components, e.g., similar reports, version history, code structure, to achieve better performance. ABLoTS is a recently proposed approach with the core component, TraceScore, that utilizes requirements and traceability information between different issue reports, i.e., feature requests and bug reports, to identify buggy source code snippets with promising results. To evaluate the accuracy of these results and obtain additional insights into the practical applicability of ABLoTS, supporting of future more efficient and rapid replication and comparison, we conducted a replication study of this approach with the original data set and also on an extended data set. The extended data set includes 16 more projects comprising 25,893 bug reports and corresponding source code commits. While we find that the TraceScore component as the core of ABLoTS produces comparable results with the extended data set, we also find that the ABLoTS approach no longer achieves promising results, due to an overlooked side effect of incorrectly choosing a cut-off date that led to training data leaking into test data with significant effects on performance.

Along the process of engineering a safety-critical system, software engineers produce various artifacts, ranging from requirements and change requests to source code and test cases. In order to aid the development of the system and to adhere to the complex safety regulations and standards in place, engineers are often required to maintain bidirectional and consistent traceability between the produced artifacts. However, such artifacts are rarely maintained in one single tool. Because of that, the cross-tool bidirectional traces have to frequently be manually maintained, which can easily become a very time-consuming or infeasible task. Through interviews and observations at our industry partners in regulated domains, we observed that a number of different strategies are used to deal with this challenge. The use of naming conventions, querying, or URL links is observed in the industry. However, they have their shortcomings and hinder engineers from realizing the full potential that traceability can offer. Knowing the challenges in the industry, we explored existing literature. A range of approaches in the literature aims at dealing with traceability, but often they are context-specific and not easily transferable into practice. Given this gap between the state-of-the-art and industry needs, we performed interviews with our industry partners and analyzed tertiary studies from the literature to obtain a better understanding of what traceability properties are needed to unleash the potential of traces. We identified properties that represent the shared challenges between the related work and the industry requirements: discoverability, type checks, flexibility, navigability, and extensibility. While each property is addressed by a subset of the available solutions, we propose a novel traceability approach to support all of them in a single tool.

Adapting the behavior of robots and their interaction with other machines on the shop floor is typically accomplished by non-programmers. Often these non-programmers use visual languages to specify the robot’s and/or machine’s control logic. While visual languages are explored as a means to enable novices to program, there is little understanding of what problems novices face when tasked with realistic adaptation programming tasks on the shop floor. In this paper, we report the results of a controlled experiment where domain experts in the injection molding industry inspected and changed realistic programs involving a robot, injection molding machine, and additional external machines. We found that participants were comparably quick to understand the program behavior with a familiar sequential function chart-based language and a Blockly-based language used for the first time. We also observed that these non-programmers had difficulty in multiple aspects independent of language due to the interweaving of physical and software-centric interaction between robot and machine. We conclude that assistance needs to go beyond optimizing available language elements to include suggesting relevant programming elements and their sequence.

When dealing with safety–critical systems, various regulations, standards, and guidelines stipulate stringent requirements for certification and traceability of artifacts, but typically lack details with regards to the corresponding software engineering process. Given the industrial practice of only using semi-formal notations for describing engineering processes – with the lack of proper tool mapping – engineers and developers need to invest a significant amount of time and effort to ensure that all steps mandated by quality assurance are followed. The sheer size and complexity of systems and regulations make manual, timely feedback from Quality Assurance (QA) engineers infeasible. In order to address these issues, in this paper, we propose a novel framework for tracking, and “passively” executing processes in the background, automatically checking QA constraints depending on process progress, and informing the developer of unfulfilled QA constraints. We evaluate our approach by applying it to three case studies: a safety–critical open-source community system, a safety–critical system in the air-traffic control domain, and a non-safety–critical, web-based system. Results from our analysis confirm that trace links are often corrected or completed after the work step has been considered finished, and the engineer has already moved on to another step. Thus, support for timely and automated constraint checking has significant potential to reduce rework as the engineer receives continuous feedback already during their work step.

Software systems are becoming increasingly configurable. A paradigmatic example is the Linux kernel, which can be adjusted for a tremendous variety of hardware devices, from mobile phones to supercomputers, thanks to the thousands of configurable features it supports. In principle, many relevant problems on configurable systems, such as completing a partial configuration to get the system instance that consumes the least energy or optimizes any other quality attribute, could be solved through exhaustive analysis of all configurations. However, configuration spaces are typically colossal and cannot be entirely computed in practice. Alternatively, configuration samples can be analyzed to approximate the answers. Generating those samples is not trivial since features usually have inter-dependencies that constrain the configuration space. Therefore, getting a single valid configuration by chance is extremely unlikely. As a result, advanced samplers are being proposed to generate random samples at a reasonable computational cost. However, to date, no sampler can deal with highly configurable complex systems, such as the Linux kernel. This paper proposes a new sampler that does scale for those systems, based on an original theoretical approach called extensible logic groups. The sampler is compared against five other approaches. Results show our tool to be the fastest and most scalable one.

Requirement-to-code traces reveal the code location(s) where a requirement is implemented. Traceability is essential for code evolution and understanding. However, creating and maintaining requirement-to-code traces is a tedious and costly process. In this paper, we introduce TraceRefiner, a novel technique for automatically refining coarse-grained requirement-to-class traces to fine-grained requirement-to-method traces. The inputs of TraceRefiner are (1) the set of requirement-to-class traces, which are easier to create as there are far fewer traces to capture, and (2) information about the code structure (i.e., method calls). The output of TraceRefiner is the set of requirement-to-method traces (providing additional, fine-grained information to the developer). We demonstrate the quality of TraceRefiner on four case study systems (7-72KLOC) and evaluated it on over 230,000 requirement-to-method predictions. The evaluation demonstrates TraceRefiner's ability to refine traces even if many requirement-to-class traces are undefined (incomplete input). The obtained results show that the proposed technique is fully automated, tool-supported, and scalable.

The Assembly Line Balancing Problem (ALBP) is of great relevance for manufacturing companies improving the line efficiency and productivity and thus maximizing production profits. Multiple exact, heuristic and meta-heuristic methods have been applied to solve the ALBP. These optimization methods consist in producing a feasible line balance, i.e. the partitioning of assembly tasks among available work stations based on, among others, the precedence graph. Such a graph describes the technological and organizational precedence constraints between tasks. Unfortunately, the assembly precedence relations, in the automotive and related industries for example, are often outdated, incomplete or altogether unavailable. This limits the applicability of the available approaches to real-world assembly systems. Grounded in an industry use-case, we propose a novel approach for the assistance in the upfront assignment of assembly tasks to stations. We recommend station assignments relying on historical data of prior feasible assembly balances of different products. We evaluate our approach against real industry data. On average, our approach is able to provide station assignment recommendations for 91% of the tasks at 82% precision.

Cyber-physical production systems are composed of a multitude of subsystems from diverse vendors and integrators, connected in a distributed fashion. An undesirable phenomenon in one system might cause a misbehavior in another connected system. Searching for the root cause of this misbehavior quickly becomes very tedious as many possible search directions exist. This paper proposes an approach and algorithm to tie together information available in design-time and runtime models. This then allows, in conjunction with observed and desired status of a system, to recommend search options and concrete solution steps to guide workers along the fixing process without being overwhelmed by the complexity of the overall system of systems. We demonstrate the feasibility of our approach using a lab-scal production cell model.

This paper proposes a recommendation approach for issues (e.g., a story, a bug, or a task) prioritization based on natural language processing, called NLP4IP. The proposed semi-automatic approach takes into account the priority and story points attributes of existing issues defined by the project stakeholders and devises a recommendation model capable of dynamically predicting the rank of newly added or modified issues. NLP4IP was evaluated on 19 projects from 6 repositories employing the JIRA issue tracking software with a total of 29,698 issues. A comprehensive benchmark study was also conducted to compare the performance of various machine learning models. The results of the study showed an average top@3 accuracy of 81% and a mean squared error of 2.2 when evaluated on the validation set. The applicability of the proposed approach is demonstrated in the form of a JIRA plug-in illustrating predictions made by the newly developed machine learning model. The dataset has also been made publicly available in order to support other researchers working in this domain.

Regulations, standards, and guidelines for safety-critical systems stipulate stringent traceability but do not prescribe the corresponding, detailed software engineering process. Given the industrial practice of using only semi-formal notations to describe engineering processes, processes are rarely "executable" and developers have to spend significant manual effort in ensuring that they follow the steps mandated by quality assurance. The size and complexity of systems and regulations makes manual, timely feedback from Quality Assurance (QA) engineers infeasible. In this paper we propose a novel framework for tracking processes in the background, automatically checking QA constraints depending on process progress, and informing the developer of unfulfilled QA constraints. We evaluate our approach by applying it to two different case studies; one open source community system and a safety-critical system in the air-traffic control domain. Results from the analysis show that trace links are often corrected or completed after the fact and thus timely and automated constraint checking support has significant potential on reducing rework.

Unforeseen situations on the shopfloor cause the assembly process to divert from its expected progress. To be able to overcome these deviations in a timely manner, assembly process monitoring and early deviation detection are necessary. However, legal regulations and union policies often limit the direct monitoring of human-intensive assembly processes. Grounded in an industry use case, this paper outlines a novel approach that, based on indirect privacy-respecting monitored data from the shopfloor, enables the near real-time detection of multiple types of process deviations. In doing so, this paper specifically addresses uncertainties stemming from indirect shopfloor observations and how to reason in their presence.

As manufacturing companies move towards producing highly customizable products in small lot sizes, assembly workers remain an integral part of production systems. However, with workers in the loop, it is necessary to monitor the production process for timely detection of deviations and timely provisioning of worker assistance. Grounded in an industrial case study describing the assembly of construction vehicles, we outline a generic heuristic-based approach for monitoring progress in human-intensive assembly systems. Specifically, we highlight the challenges in dealing with uncertainty stemming from the limitations in accurately, timely, and completely observing human physical assembly steps. We discuss a motivating example to showcase these challenges and present a set of heuristics that manages to accurately infer assembly progress from indirect and incomplete observations of deviating worker behavior. Validated against ground truth obtained from a real industrial assembly line, on average our approach correctly estimates completion times for steps that are associated with shopfloor observations within 14 seconds or less of their true value.

Software engineers use requirement-to-method trace matrices to indicate the methods implementing different system requirements. Requirement-to-method trace matrices pinpoint the exact method implementing each requirement, which facilitates software maintenance and bug fixing. The code structure of a system can be used to make predictions about requirement-to-method traces. In this paper, we present a data set documenting the requirement-to-method traces as well as the code structure (methods, variables, etc.) for four open source systems. The code structure was obtained by parsing the systems under consideration and extracting the methods, variables, etc. The requirement-to-method trace matrices were obtained by resorting to students as well as to the original developers of the systems who provided us with the list of requirement-to-method traces.

Cyber physical production systems (CPPS) focus on increasing the flexibility and adaptability of industrial production systems, systems that comprise hardware such as sensors and actuators in machines as well as software controlling and integrating these machines. The requirements of customised mass production imply that control and integration software needs to be adaptable after deployment in a shop floor (factory), possibly even without interrupting production. Today, software frameworks provide support to model and execute manufacturing processes. They, however, provide little support for reuse. In this paper, we present a framework based on capabilities, which supports manufacturing process templates. These templates are bound/allocated to a specific shopfloor setup, a specific set of machines, and executed using a distributed set of process engines. This enables the reuse of manufacturing processes, as well as transmitting and executing changed processes. The framework is implemented using the Eclipse Milo implementation of OPC UA in Java. It is used to control a lab-scale modular shopfloor programmed in IEC61499 and Java.

The new era of Industry 4.0 is leading towards self-learning and adaptable production systems requiring efficient and intelligent decision making. Achieving high production rate in a short span of time, continuous improvement, and better utilization of resources is crucial for such systems. This paper discusses an approach to achieve production optimization by finding optimal sequences of orders, which yield high throughput using reinforcement learning. The feasibility of our approach is evaluated by simulating a plant modelled on a higher level of abstraction taken from a real assembly line. The applicability of the proposed approach is demonstrated in the form of code utilizing the simulation model. The obtained results show promising accuracy of sequences against corresponding throughput during the simulation process.

Organizational factors such as team structure, coordination among engineers, or processes have a significant impact on software quality and development progress. Projects often take much longer to complete than planned and miscommunications among engineers are common. Yet, the process for exploring the project-specific or organization-specific root causes why this happens is still poorly supported. Investigations are cumbersome and require significant effort. In the context of this industrial case study, our industry partner was interested in measuring and assessing how the organization structure and issue handling processes ultimately affected software quality and time. Reducing the effort of such investigations/retrospectives and speeding up fact finding is important as it allows for more frequent, informed engineering process improvements and feedback to managers, team leads, and engineers. This paper describes our approach of pairing process metrics with visual historical inspection of issues. Stakeholders such as managers, team leads, or quality assurance engineers inspect metrics (and deviations from expected values) for individual issues and utilize a historical visualization of the affected (and related) issues to obtain insights into the reason for the metric (deviation) and its root cause. We demonstrate the usefulness of our approach based on our ProcessInspector prototype providing access to data on four real industry projects and a qualitative evaluation with team leads and group leads from our industry partner.

Several researchers have studied that developers contributing to open source systems tend to self-organize in "emerging" teams. The structure of these latent teams has a significant impact on software quality, with development teams structure somewhat reflected in the way developers communicate and contribute in the subsystems of a system. Therefore, in order to study socio-technical interactions as well as the software evolution dynamics of open source systems, in this paper, we present a novel dataset, gathered from 20 open source projects, which report the developers' activities in the scope of commits and issues at the level of subsystems. Thus, the new, generated dataset comprises of emerging and explicit links among developers, commits, issues, and source code artifacts, with data grouped around the subsystems point of view, which can be used to better study the system dynamics behind the extracted sociotechnical interactions.

Variability models are broadly used to specify the configurable features of highly customizable software. In practice, they can be large, defining thousands of features with their dependencies and conflicts. In such cases, visualization techniques and automated analysis support are crucial for understanding the models. This paper contributes to this line of research by presenting a novel, probabilistic foundation for statistical reasoning about variability models. Our approach not only provides a new way to visualize, describe and interpret variability models, but it also supports the improvement of additional state-of-the-art methods for software product lines; for instance, providing exact computations where only approximations were available before, and increasing the sensitivity of existing analysis operations for variability models. We demonstrate the benefits of our approach using real case studies with up to 17,365 features, and written in two different languages (KConfig and feature models).

Most software development organizations nowadays use issue-tracking tools to manage software processes throughout the life-cycle. Still, understanding development processes, keeping track of process execution, and reacting to deviations in projects remains challenging. In particular, the actual process usually differs from the process perceived by developers, making it hard to define the processes developers are expected to carry out. This is further challenged by frequently changing processes and process variations in different projects and teams. In this paper we describe an empirical study in which we applied a constraint mining approach from the field of software monitoring to automatically extract process definitions in the form of constraints. Specifically, we applied the approach to datasets extracted from four real-world projects (using the Jira issue-tracking tool) in a company developing a recreational activities platform. The mined constraints describe the boundaries of the actual processes and thus help to understand process behavior. Constraints can be frequently re-mined to understand process evolution. The mined constraints can also be used to monitor future processes to detect problems in the development process early on. We involved a domain expert to evaluate the usefulness of our results and investigated to what extent the mined constraints reflect the official development process of the company. We also report mining results for different issue types, across projects, and over different time windows.

Implementing a change is a challenging task in complex, safety-critical, or long-living software systems. Developers need to identify which artifacts are affected to correctly and completely implement a change. Changes often require editing artifacts across the software system to the extent that several developers need to be involved. Crucially, a developer needs to know which artifacts under someone else's control have impact on her work task and, in turn, how her changes cascade to other artifacts, again, under someone else's control. These cross-task dependencies are especially important as they are a common cause of incomplete and incorrect change propagation and require explicit coordination. Along these lines the core research question in this paper is: how can we automatically detect cross-task dependencies and use them to assist the developer? We introduce an approach for mining such dependencies from past developer interactions with engineering artifacts as the basis for live recommending artifacts during change implementation. We show that our approach lists 67% of the correctly recommended artifacts within the top-10 results with real interaction data and tasks from the Mylyn project. The results demonstrate we are able to successfully find not only cross-task dependencies but also provide them to developers in a useful manner.

Developers commonly define tasks to help coordinate software development efforts---whether they be feature implementation, refactoring, or bug fixes. Developers establish links between tasks to express implicit dependencies that needs explicit handling---dependencies that often require the developers responsible for a given task to assess how changes in a linked task affect their own work and vice versa (i.e., change propagation). While seemingly useful, it is unknown if change propagation indeed coincides with task links.

Manually managing collaboration becomes a problem in distributed software engineering environments. Individual engineers easily loose track of who to involve and when. The result is lack of communication, alternatively communication overload, leading to errors and rework. This paper presents a Domain-Specific Language (DSL) for scripting of collaboration structures and their evolution. We demonstrate the DSL's benefits and expressiveness for setting up an iteration planning meeting in an agile development setting.

Summary The recent two decades have witnessed the emergence of large‐scale, interaction‐intensive systems. A system's provided user‐centric communication and coordination mechanisms have a significant impact on its runtime management. Beyond a certain size, manual monitoring and management are no longer feasible. Hence, it is highly important for a system designer to becoming aware of the most suitable interaction mechanisms and their implications on system adaptability. Specifically, a system designer requires knowledge on what adaptation primitives are available, whether these are system‐driven or user‐driven, how long they will take, what impact do they have on collaboration state, and under what conditions they can be enacted. These aspects vary considerably across collaboration patterns. In this paper, we investigate a collaboration structure's adaptability based on behavior, asynchrony, state, and execution context. We subsequently discuss seven distinctively different collaboration patterns in terms of those aspects. Based on a motivating scenario, we ultimately demonstrate how these patterns and insights into their inherent adaptability may guide design decision impact and trade‐off analysis. Copyright © 2014 John Wiley & Sons, Ltd.

The context of software architecting increasingly reflects webs of IT companies pooling resources together for software development. What results is a networked organization, populated by heterogeneous development communities connected via internet. How does this scenario change the process of software architecting? Pivoting around this research question, this paper presents architecture concerns relevant in such networked development scenarios. Supporting these concerns is critical to understand the impact of architecture on organizational change and vice versa. To this aim, we introduce a viewpoint, its supporting tool and evaluate both through a case-study.

The emergence of socio-technical systems characterized by significant user collaboration poses a new challenge for system adaptation. People are no longer just the “users” of a system but an integral part. Traditional self-adaptation mechanisms, however, consider only the software system and remain unaware of the ramifications arising from collaboration interdependencies. By neglecting collective user behavior, an adaptation mechanism is unfit to appropriately adapt to evolution of user activities, consider side-effects on collaborations during the adaptation process, or anticipate negative consequence upon reconfiguration completion. Inspired by existing architecture-centric system adaptation approaches, we propose linking the runtime software architecture to the human collaboration topology. We introduce a mapping mechanism and corresponding framework that enables a system adaptation manager to reason upon the effect of software-level changes on human interactions and vice versa. We outline the integration of the human architecture in the adaptation process and demonstrate the benefit of our approach in a case study.

Human collaboration has become an integral part of large-scale systems for massive online knowledge sharing, content distribution, and social networking. Maintenance of these complex systems, however, still relies on adaptation mechanisms that remain unaware of the prevailing user collaboration patterns. Consequently, a system cannot react to changes in the interaction behavior thereby impeding the collaboration's evolution. In this paper, we make the case for a human architecture model and its mapping onto software architecture elements as fundamental building blocks for system adaptation.

Web-based collaboration and virtual environments supported by various Web 2.0 concepts enable the application of numerous monitoring, mining and analysis tools to study human interactions and team formation processes. The composition of an effective team requires a balance between adequate skill fulfillment and sufficient team connectivity. The underlying interaction structure reflects social behavior and relations of individuals and determines to a large degree how well people can be expected to collaborate. In this paper we address an extended team formation problem that does not only require direct interactions to determine team connectivity but additionally uses implicit recommendations of collaboration partners to support even sparsely connected networks. We provide two heuristics based on Genetic Algorithms and Simulated Annealing for discovering efficient team configurations that yield the best trade-off between skill coverage and team connectivity. Our self-adjusting mechanism aims to discover the best combination of direct interactions and recommendations when deriving connectivity. We evaluate our approach based on multiple configurations of a simulated collaboration network that features close resemblance to real world expert networks. We demonstrate that our algorithm successfully identifies efficient team configurations even when removing up to 40% of experts from various social network configurations.

The inadequate quality of context forces the context consumers in pervasive environments to reason about the quality and relevance of context to be confident of its worth to perform their functionality. The additional task of analyzing large volumes of context drastically affects the performance of the context consumers to adjust to dynamically changing situations. A single value that presents the quality and relevance of context information tailored to the needs of a particular context consumer may release them from spending resources on context quality analysis and let them concentrate on their main task. In this paper we present a novel technique to combine different Quality of Context (QoC) metrics to infer the value of confidence on context. Our technique also considers the requirements of a particular context consumer regarding QoC metrics while confidence inference. Confidence on context is further provided to the context consumers to select high quality context and use the confidence in their functionality. We have successfully evaluated our approach using two context consumer services and user context collected from a smart home pervasive environment.

Mashup tools are becoming increasingly important enabling users to compose services and processes on the Web. Most existing tools focus on Web-based interfaces, usability, and visual languages for creating mashups. A major challenge that has received limited attention is context-awareness and adaptivity of service mashups. In this paper we focus on two main aspects: First, a service capability model describing service characteristics that can be tracked and matched against the requirements associated with service mashups and second an algorithm to recommend refinements such as replacing services within mashups. We implemented a set of adaptation algorithms to validate our approach in real service-oriented systems.

In this paper we present the concept of activity-centric collaboration using service-oriented architectures (ACCUSO), which addresses the requirements arising from ad-hoc collaboration in mobile teams. In ACCUSO, activities are used to map human actions to Web services exploiting the potential benefits of SOA, such as service discovery and binding at run time. The possibility to compose activities hierarchically from sub-activities and to redesign running activities provides the process-flexibility required in ad-hoc collaboration. We expand the notion of service orientation by introducing human-provided services (HpS) which provide functionality not realizable through software services. HpS are "implemented" by human actors (possibly being mobile), which remains transparent to the system, thereby allowing for the provisioning of HpS based on conventional WS-infrastructure. The feasibility and applicability of ACCUSO is demonstrated through a proof-of-concept implementation.

In collaborative working environments (CWE), human interaction patterns represent reoccurring situations describing the sequence and type of interactions between individuals. We believe that such patterns provide information that may be used to improve human collaboration. In this paper we introduce interaction patterns to an existing context sharing platform used by distributed teams. We use these patterns to formulate rules that help determining the relevance of context information between users and that raise team awareness between interacting entities. These rules are integrated in an existing platform for context sharing between mobile users which allows us to demonstrate the practical applicability of our approach