Overview

Software processes together with software Quality Assurance (QA) focus
on ensuring and attesting that the engineering processes result in the
appropriate software quality.
Yet, there exists a tension between the need to follow regulations and
the process on the one hand, and the need to be able to deviate on the
other hand.
The problem is then how to provide automated process guidance to
engineers in the presence of violated process and quality constraints.

This is non-trivial as a process deviation typically affects not only a
single engineer but has impact on other engineers as well. Without
awareness of process deviation and its impact on others, a deviation
(such as an unfulfilled QA constraint) may go unnoticed or not be
completely corrected. The constraint violation then may propagate to
subsequent process steps and their engineering artifacts, ultimately
leading to costly rework at a later time or lower software quality.

We argue that guidance needs to come in two forms. First, supporting
engineers in determining which activities are needed to return to a
consistent process state, and second, identifying what are the affected
process steps and their responsible engineers.

In this project, we will manage software engineering processes and their
QA constraints passively in the background so that engineers may
flexibly deviate from the process. We then identify root causes to
reason about who needs to coordinate in repairing a deviation. We also
determine the deviation impact scope to identify the subsequent effect
on others. Matching deviations with repair templates supports the
engineers in returning to a consistent process state.
The key innovation is providing guidance even for those engineers
implicated in a deviation.

The research agenda envisions the integration of the newly established
models, techniques, and algorithms in a proof-of-concept prototype for
evaluation with our industry evaluation collaborator under realistic
conditions.
Ultimately we expect such guidance to reduce the time in a deviating
state, and thus the potential for unintended constraint violation
propagation, which in turn reduces the amount of errors and subsequent
rework that cascades beyond an initial deviation.