In software development, domain models are conceptual blueprints that capture the structure, relationships, and key entities of a problem domain. Automated techniques can support analysts and developers by extracting such models from existing artifacts. However, this is a non-trivial task, especially when the input consists of informal artifacts such as user stories. This paper investigates how providing an initial, automatically generated domain model influences novice developers’ ability to construct their own domain models. We conducted an experiment involving 127 undergraduate students, divided into three groups: one receiving an LLM-generated model that maximizes precision (validity), one receiving an LLM-generated model that boosts recall (completeness), and a control group that did not receive any initial domain model. Our findings show that novices who received an initial LLM-generated model produced more complete class identification in simple user story projects and improved relationship identification accuracy in both simple and complex projects. While initial domain models appear to aid novices in refining domain models effectively, our results also suggest a strong tendency among participants to rely heavily on these initial models. On average, students included 85% of the correct classes and 67% of the incorrect classes from the initial domain models in their own derived models. Such reliance can scaffold novice learning and refinement, but this reliance may limit creativity and hinder the deeper reasoning required to develop robust domain modeling skills.

Issue Tracking Systems (ITSs) serve multiple purposes in software development: they represent requirements and bugs, facilitate communication between team members, and support project management by assigning tasks. As software systems and projects increase in complexity, the number of work items and their relationships grows considerably, forming a complex network that is difficult and time-consuming for team members to navigate using traditional ITSs. Motivated by the interest of two companies in exploring the use of Artificial Intelligence in software development, we introduce the GraphRAG Dialogue Insights (GDI) framework. GDI uses knowledge graphs, Retrieval-Augmented Generation (RAG), and Large Language Models (LLMs) to enable users to query work items in natural language (NL). In addition to a NL response, GDI returns supporting information to help users understand how the LLMs queried the knowledge graph. We empirically validate GDI through two proof-of-concept implementations, each addressing a use case: i) onboarding and ii) trace link recovery. Initial user-centered validations indicate that practitioners find the system intuitive, useful, and accurate in generating responses. Moreover, they express willingness to adopt the system and identify additional potential use cases, including impact analysis, troubleshooting, and issue resolution. However, further refinement is required to deploy the system in practice.

[Context] In agile software development, requirements are frequently represented in lightweight artifacts such as user stories (USs). To support their validation, USs may be complemented with additional artifacts such as acceptance criteria and test cases. [Problem] Existing studies propose frameworks for US writing, or investigate high-level factors that contribute to productivity, such as teamwork and support from management. However, empirical evidence on the impact of requirements artifacts on team efficiency is scarce. [Method] Through a mixed-methods case study at a large Dutch organization, we investigate how the use of requirements artifacts affects efficiency. We collected data from eight agile teams: 1,345 USs from nineteen sprints, US quality indicators, the quantity of associated acceptance criteria and test cases, and cycle time. We statistically analyzed the existence of correlations between these variables, and we triangulated our results through interviews with product owners and scrum masters from the involved teams. [Findings] Our employed indicators for US quality do not seem to have an effect on on-time completion, with our interviewees highlighting the trade-off between investing on writing quality and short-term efficiency. We found, instead, that the existence of acceptance criteria may be a relevant factor for on-time completion, as confirmed both by statistical tests and the interviewees.

Despite the growing interest in integrating Large-Language Models (LLMs) within software development, there is limited empirically-grounded guidance for teams to effectively apply this technology in industry. We explore the use of LLMs for generating requirements artifacts within a low-code consultancy organization that builds low-code development applications following a custom Agile model-driven development (Agile MDD) process. Through the analysis of multiple project cases within the company, we construct a method as an accurate representation of the employed Agile MDD approach. We then identify high-potential use cases for LLM adoption within the Agile MDD method. For these use cases, we engineer reusable LLM prompts that generate requirements artifacts. We validate the generated output for three of such use cases: generation of user stories, of acceptance criteria, and of data models. The team members of four projects were asked to express their opinion on the automatically generated artifacts. The results show high appreciation for the artifacts, which were found to be mainly relevant and similar to requirements that were included in the initial specification. The generation of the data model was rated less positively than the other use cases. Besides providing detailed insights on the inclusion of LLMs in the company’s Agile MDD process, we share our results to provide guidance for other software teams seeking to leverage LLMs in Agile MDD.

In scientific domains, definitions provide a precise description of fundamental concepts. Although the debate within the philosophy of computer science regarding the scientific nature of software engineering (SE) is inconclusive, SE researchers have laid down important steps toward treating SE as a scientific paradigm. We aim to support precise and effective communication among SE researchers and practitioners by providing a systematic process for the identification and analysis of definitions, in order to support the selection of a suitable definition for a certain use case. Inspired by methods for the planning and execution of systematic literature reviews, we construct a method that is specific for concept definition reviews (CDRs). These reviews are performed whenever a research team wishes to obtain a detailed understanding of an SE concept that may have been characterized by dozens, if not hundreds, definitions. We built our method via two design science iterations. The first one focused on the concept feature and resulted in the definitive version of the CDR method presented in this paper. We then applied the revised method to two, related concepts: quality requirement and non-functional requirement . Besides showing the applicability of the CDR method, our results include findings regarding the characteristics and evolution of the terms. The two applications of the CDR method highlight the existence and citation of hundreds of definitions, many of which are nearly (but not exactly) identical. We put forward our method for other researchers to shed light on the key terminology in other sub-fields of SE. • Concept definition review as a feasible method for studying domain terms. • The term non-functional requirement is more often defined than quality requirement. • Community largely considers non-functional and quality requirement interchangeable.

Software qualities such as usability or reliability are among the strongest determinants of mobile app user satisfaction and constitute a significant portion of online user feedback on software products, making it a valuable source of quality-related feedback to guide the development process. The abundance of online user feedback warrants the automated identification of quality characteristics, but the online user feedback’s heterogeneity and the lack of appropriate training corpora limit the applicability of supervised machine learning. We therefore investigate the viability of three approaches that could be effective in low-data settings: language patterns (LPs) based on quality-related keywords, instructions for crowdsourced micro-tasks, and large language model (LLM) prompts. We determined the feasibility of each approach and then compared their accuracy. For the complex multiclass classification of quality characteristics, the LP-based approach achieved a varied precision (0.38–0.92) depending on the quality characteristic, and low recall; crowdsourcing achieved the best average accuracy in two consecutive phases (0.63, 0.72), which could be matched by the best-performing LLM condition (0.66) and a prediction based on the LLMs’ majority vote (0.68). Our findings show that in this low-data setting, the two approaches that use crowdsourcing or LLMs instead of involving experts achieve accurate classifications, while the LP-based approach has only limited potential. The promise of crowdsourcing and LLMs in this context might even extend to building training corpora.

Software development is constantly evolving, adapting to emerging technologies and development paradigms while leveraging advancements in communication technologies and work modes. We conduct an exploratory case study in a large software organization to investigate how the development paradigm and the formality of communication channels affect written communication within hybrid teams. We perform statistical and content analysis of written conversations from 20 projects involving two software products that use industry adaptations of the Waterfall model and of Scrum, respectively. We found that in agile-developed projects, communication related to the execution-monitoring-control phase of the Project Management Life Cycle is more prevalent, and communication related to the initiation phase occurs more frequently in informal channels. For both project types, communication primarily pertains to the software construction phase of the Software Development Life Cycle. After annotating communication contents using speech acts, representatives are found to be prevalent in informal channels for agile-developed projects, directives are more prevalent in informal channels for waterfall-developed projects, and expressives are more frequent in informal channels for both project types. We provide empirical evidence that development paradigms and communication channel formality impact written communication, with agile-developed projects showing more collaborative interactions in informal channels compared to waterfall-developed projects. Editor’s note: Open Science material was validated by the Journal of Systems and Software Open Science Board . • We analyze the written communication of 20 projects in the software industry. • We compare the projects in terms of development paradigm and channel formality. • We applied statistical and content analyses to the communication contents. • We find that development paradigm and channel formality impact written communication.

Domain models play a crucial role in software development, as they provide means for communication among stakeholders, for eliciting requirements, and for representing the information structure behind a database scheme or at the basis of model-driven development. However, creating such models is a tedious activity and automated support may assist in obtaining an initial domain model that can later be enriched by human analysts. In this paper, we propose an experimental comparison of the effectiveness of various approaches for deriving domain models from a given set of user stories. We contrast human derivation with machine derivation; for the latter, we compare (i) the Visual Narrator: an existing rule-based NLP approach; (ii) a machine-learning classifier that we feature engineered; and (iii) a generative AI approach that we constructed via prompt engineering. Based on a benchmark dataset that consists of nine collections of user stories and corresponding domain models, the evaluation indicates that no approach matches human performance, although a tuned version of the machine learning approach comes close. To better understand the results, we qualitatively analyze them and identify differences in the types of false positives as well as other factors that affect performance.

Natural language processing (NLP) techniques have been widely applied in the requirements engineering (RE) field to support tasks such as classification and ambiguity detection. Despite its empirical vocation, RE research has given limited attention to replication of NLP for RE studies. Replication is hampered by several factors, including the context specificity of the studies, the heterogeneity of the tasks involving NLP, the tasks’ inherent hairiness , and, in turn, the heterogeneous reporting structure. To address these issues, we propose a new artifact, referred to as ID-Card , whose goal is to provide a structured summary of research papers emphasizing replication-relevant information. We construct the ID-Card through a structured, iterative process based on design science. In this article: (i) we report on hands-on experiences of replication; (ii) we review the state-of-the-art and extract replication-relevant information: (iii) we identify, through focus groups, challenges across two typical dimensions of replication: data annotation and tool reconstruction; and (iv) we present the concept and structure of the ID-Card to mitigate the identified challenges. This study aims to create awareness of replication in NLP for RE. We propose an ID-Card that is intended to foster study replication but can also be used in other contexts, e.g., for educational purposes.

In multi-agent systems, norm enforcement is a mechanism for steering the behavior of individual agents in order to achieve desired system-level objectives. Due to the dynamics of multi-agent systems, however, it is hard to design norms that guarantee the achievement of the objectives in every operating context. Also, these objectives may change over time, thereby making previously defined norms ineffective. In this paper, we investigate the use of system execution data to automatically synthesise and revise conditional prohibitions with deadlines, a type of norms aimed at preventing agents from exhibiting certain patterns of behaviors. We propose DDNR (Data-Driven Norm Revision), a data-driven approach to norm revision that synthesises revised norms with respect to a data set of traces describing the behavior of the agents in the system. We evaluate DDNR using a state-of-the-art, off-the-shelf urban traffic simulator. The results show that DDNR synthesises revised norms that are significantly more accurate than the original norms in distinguishing adequate and inadequate behaviors for the achievement of the system-level objectives.

Welcome to the proceedings of the 31st edition of the IEEE International Requirements Conference (RE'23), the flagship conference of the international RE community. RE is where researchers, practitioners and students meet to share the latest advances, challenges and ideas related to software and systems requirements engineering.

Abstract Context Automated classifiers, often based on machine learning (ML), are increasingly used in software engineering (SE) for labelling previously unseen SE data. Researchers have proposed automated classifiers that predict if a code chunk is a clone, if a requirement is functional or non-functional, if the outcome of a test case is non-deterministic, etc. Objective The lack of guidelines for applying and reporting classification techniques for SE research leads to studies in which important research steps may be skipped, key findings might not be identified and shared, and the readers may find reported results (e.g., precision or recall above 90%) that are not a credible representation of the performance in operational contexts. The goal of this paper is to advance ML4SE research by proposing rigorous ways of conducting and reporting research. Results We introduce the ECSER (Evaluating Classifiers in Software Engineering Research) pipeline, which includes a series of steps for conducting and evaluating automated classification research in SE. Then, we conduct two replication studies where we apply ECSER to recent research in requirements engineering and in software testing. Conclusions In addition to demonstrating the applicability of the pipeline, the replication studies demonstrate ECSER’s usefulness: not only do we confirm and strengthen some findings identified by the original authors, but we also discover additional ones. Some of these findings contradict the original ones.

Requirements Traceability (RT) is concerned with monitoring and documenting the lifecycle of requirements. Although researchers have proposed several automated tracing tools, trace link establishment and maintenance are still prevalently manual activities. In order to foster the adoption of automated tracing tools, we study their empirical effectiveness in the context of model-driven development (MDD). We focus on trace link recovery (TLR) from (i) SVN revisions of MDD models to (ii) JIRA issues that represent requirements and bugs. Based on the state-of-the-art in automated TLR, we propose the LCDTrace tool that uses 131 features to train a machine learning classifier. Some of these features use specific information for MDD contexts. We conduct three experiments on ten datasets from seven MDD projects. First, we evaluate the effectiveness of three ML algorithms and four rebalancing strategies using all 131 features, and we derive two optimal combinations for trace link recommendation and for trace maintenance. Second, we investigate whether the MDD-specific features convey higher performance than a version of LCDTrace that excludes those features. Third, we employ automated feature selection and study whether we can reduce the number of features while keeping similar performance, thereby boosting time and energy efficiency. In our experiments, the gradient boosting models outperform those based on random forests. The best combinations for trace recommendation and maintenance achieve an F2-score of 61% and F0.5-score of 67%, respectively. While MDD-specific features do not provide additional value, automated feature selection succeeds at reducing feature numerosity without compromising performance. We provide insights on the effectiveness of state-of-the-art TLR techniques in MDD. Our findings are a baseline for devising and experimenting with alternative TLR approaches.

Abstract Researchers have proposed numerous tools, methods, and techniques for establishing and maintaining software traceability. Despite its acknowledged importance, researchers argue that traceability is still “a sought-after, yet often elusive quality in software-intensive systems”. We have little evidence regarding how creating, managing, and using traceability links vary depending on factors such as organizational contexts, software development practices, and project types. We conduct an empirical study where software development practitioners express their perception regarding the value of software traceability. Via an online survey, 55 participants provided information related to their current traceability practices and needs. Furthermore, we interviewed 14 practitioners to gain a more in-depth understanding. Our study investigates the effect of two independent variables: the software development paradigm and the type of developed software system. Among the several identified findings, our analysis reveals that, although the traceability costs are an inhibitor for adopting more mature traceability practices, the respondents believe that the expected benefits still outweigh envisioned costs. Traceability is mainly performed manually: not only are automated trace retrieval tools scarce, but their offered automation is not expected to replace human involvement.

Pre-requirements specification (pre-RS) traceability focuses on tracing requirements back to their sources. In comparison with post-RS traceability, pre-RS traceability is an under-explored area of research. Likely reasons for the limited studies are the scarcity of pre-RS resources, e.g., recorded requirements elicitation conversations such as interviews or workshops, and the challenges of linking requirements to informal, unstructured text. Building on the increasing use of digital communication tools that allow the recording and transcription of conversations, we explore the opportunity of linking requirements to the transcript of a requirements elicitation conversation. We introduce TRACE2CoNV, a prototype tool that aims at tracing user story requirements back to the relevant speaker turns in a conversation. TRACE2CoNV makes use of NLP techniques to determine the relevant speaker turns. As an initial validation, we take automatically generated transcripts from real-world requirements conversations, and we assess the effectiveness of TRACE2CoNV in supporting the process of identifying additional context for the requirements. The validation serves as a formative evaluation that guides the evolution of TRACE2CoNV and as a inspiration for future research in the field of conversational RE.

In multi-agent systems, norm enforcement is a mechanism for steering the behavior of individual agents in order to achieve desired system-level objectives. Due to the dynamics of multi-agent systems, however, it is hard to design norms that guarantee the achievement of the objectives in every operating context. Also, these objectives may change over time, thereby making previously defined norms ineffective. In this paper, we investigate the use of system execution data to automatically synthesise and revise conditional prohibitions with deadlines, a type of norms aimed at prohibiting agents from exhibiting certain patterns of behaviors. We propose DDNR (Data-Driven Norm Revision), a data-driven approach to norm revision that synthesises revised norms with respect to a data set of traces describing the behavior of the agents in the system. We evaluate DDNR using a state-of-the-art, off-the-shelf urban traffic simulator. The results show that DDNR synthesises revised norms that are significantly more accurate than the original norms in distinguishing adequate and inadequate behaviors for the achievement of the system-level objectives.

Crowd-based Requirements Engineering (CrowdRE) promotes the active involvement of a large number of stakeholders in RE activities. A prominent strand of CrowdRE research concerns the creation and use of online platforms for a crowd of stakeholders to formulate ideas, which serve as an additional input for requirements elicitation. Most of the reported case studies are of small size, and they analyze the size of the crowd, rather than the quality of the collected ideas. By means of an iterative design that includes three case studies conducted at two organizations, we present the CREUS method for crowd-based elicitation via user stories. Besides reporting the details of these case studies and quantitative results on the number of participants, ideas, votes, etc., a key contribution of this paper is a qualitative analysis of the elicited ideas. To analyze the quality of the user stories, we apply criteria from the Quality User Story framework, we calculate automated text readability metrics, and we check for the presence of vague words. We also study whether the user stories can be linked to software qualities, and the specificity of the ideas. Based on the results, we distill six key findings regarding CREUS and, more generally, for CrowdRE via pull feedback.

New techniques for managing, specifying, and analyzing requirements in software engineering projects are frequently presented by consultants and agile trainers. However, the effectiveness of these techniques is not evaluated in a rigorous manner, leaving practitioners with the question “Will it work in our company?” In this paper, we investigate the performance of a user story refinement technique named Example Mapping (EM). This is a time-boxed workshop in which people from different disciplines work collaboratively in order to refine, or clarify, a user story with the use of examples. The creation of such examples is intended not only to obtain a more precise specification, but also and mostly to achieve shared understanding on the user story to develop among the team members. We investigate the performance of EM via two longitudinal case studies. To enable a rigorous validation of EM, we first define the Refinement Evaluation Tool (RET), a survey-based measurement instrument that extends the Method Evaluation Model with questions that cover the shared understanding dimension. The results from our case studies show that EM contributes to the shared understanding within a team; certain conditions are necessary: the user stories should not be too small-sized. We also investigated the learning effect for EM; our data indicates that two sessions are generally necessary for the team members to use the technique effectively.

Most agile practitioners employ user stories for capturing requirements, also thanks to the embedding of this notation within development and project management tools. Among user story users, circa 70% follow a simple template: As a role, I want to action, so that benefit. User stories’ popularity among practitioners and their template-based structure make them ideal candidates for the application of natural language processing techniques. In our research, we have found that circa 50% of real-world user stories contain easily preventable linguistic defects. To mitigate this problem, we have created tool-supported methods that facilitate the creation of better user stories. This tutorial combines previous work of the RE-Lab@UU into a pipeline for working with user stories: (1) The basics of creating user stories and their use in requirements engineering; (2) How to improve user story quality with the Quality User Story Framework and the AQUSA tool; (3) How to generate conceptual models from user stories using the Visual Narrator tool and analyze them for possible ambiguity and inconsistency; and (4) How to link requirements to architectures via the RE4SA model. Our approach is demonstrated with results obtained from 20+ software companies employing user stories.

Crowd-based Requirements Engineering, or CrowdRE, is a recent paradigm that promotes the active participation of a large number of stakeholders in RE. In CrowdRE, requirements elicitation can be crowdsourced by creating an online platform that allows stakeholders to formulate ideas regarding the specific product. Although some case studies on crowd-based elicitation exist, no conclusive evidence can be derived on the effectiveness of such techniques. In this paper, we study crowd-based elicitation within a large governmental organization. We conduct two case studies of CrowdRE within the Royal Netherlands Marechaussee. For this, we construct the KMar-Crowd method, which adapts CrowdRE ideas to the needs of governmental organizations. While one case compares the crowd-generated ideas with requirements elicited via interviews and similar techniques, the other measures the usefulness of the gathered ideas for a product for which no prior elicitation was conducted. The results of the case studies, which attracted larger crowds than in previous studies, indicate that CrowdRE can be successfully applied to engage the users of a software product in requirements elicitation. Contradicting earlier studies, the inclusion of gamification elements in the CrowdRE method did not increase the motivation to participate, possibly due to the nature of governmental organizations.

Context: There are numerous textual notations and techniques that can be used in requirements engineering. Currently, practitioners make a choice without having scientific evidence regarding their suitability for given tasks. This uninformed choice may affect task performance. Objective: In this research, we investigate the adequacy of two well-known notations: use cases and user stories, as a starting point for the manual derivation of a structural conceptual model that represents the domain of the system. We also examine other factors that may affect the performance of this task. Methods: This work relies on two experiments. The first is a controlled classroom experiment. The second one is a quasi-experiment, conducted over multiple weeks, that aims at evaluating the quality of the derived conceptual model in light of the notation used, the adopted derivation process, and the complexity of the system to be. We measure quality in terms of validity and completeness of the conceptual model. Results: The results of the controlled experiment indicate that, for deriving conceptual models, user stories fit better than use cases. Yet, the second experiment indicates that the quality of the derived conceptual models is affected mainly by the derivation process and by the complexity of the case rather than the notation used. Contribution: We present evidence that the task of deriving a conceptual model is affected significantly by additional factors other than requirements notations. Furthermore, we propose implications and hypotheses that pave the way for further studies that compare alternative notations for the same task as well as for other tasks. Practitioners may use our findings to analyze the factors that affect the quality of the conceptual model when choosing a requirements notation and an elicitation technique that best fit their needs.

Requirements engineering and software architecture are tightly linked disciplines. The Twin Peaks model suggests that requirements and architectural components should stay aligned while the system is designed and as the level of detail increases. Unfortunately, this is hardly the case in practical settings. We surmise that a reason for the absence of conjoint evolution is that existing models, such as the Twin Peaks, do not provide concrete guidance for practitioners. We propose the Requirements Engineering for Software Architecture (RE4SA) model to assist in analyzing the alignment and the granularity of functional requirements and architectural components. After detailing the RE4SA model in notation-independent terms, we propose a concrete instance, called RE4SA-Agile, that connects common artifacts in agile development, such as user stories and features. We introduce metrics that measure the alignment between the requirements and architecture, and we define granularity smells to pinpoint situation in which the granularity of one high-level requirement or high-level component is not uniform with the norm. We show two applications of RE4SA-Agile, including the use of the metrics, to real-world case studies. Our applications of RE4SA-Agile, which were discussed with representatives from the development teams, prove to be able to pinpoint problematic situations regarding the relationship between functional requirements and architecture. RE4SA and its metrics can be seen as a first attempt to provide a concrete approach for supporting the application of the Twin Peaks model. We expect future research to apply our metrics to additional cases and to provide variants for RE4SA that support different concrete notations, and extend the perspective beyond the functional perspective of this research, similar to what we did with RE4SA-Agile in this paper.

Abstract To achieve system-level properties of a multiagent system, the behavior of individual agents should be controlled and coordinated. One way to control agents without limiting their autonomy is to enforce norms by means of sanctions. The dynamicity and unpredictability of the agents’ interactions in uncertain environments, however, make it hard for designers to specify norms that will guarantee the achievement of the system-level objectives in every operating context. In this paper, we propose a runtime mechanism for the automated revision of norms by altering their sanctions. We use a Bayesian Network to learn, from system execution data, the relationship between the obedience/violation of the norms and the achievement of the system-level objectives. By combining the knowledge acquired at runtime with an estimation of the preferences of rational agents, we devise heuristic strategies that automatically revise the sanctions of the enforced norms. We evaluate our heuristics using a traffic simulator and we show that our mechanism is able to quickly identify optimal revisions of the initially enforced norms.

Requirements classification is a traditional application of machine learning (ML) to RE that helps handle large requirements datasets. A prime example of an RE classification problem is the distinction between functional and non-functional (quality) requirements. State-of-the-art classifiers build their effectiveness on a large set of word features like text n-grams or POS n-grams, which do not fully capture the essence of a requirement. As a result, it is arduous for human analysts to interpret the classification results by exploring the classifier's inner workings. We propose the use of more general linguistic features, such as dependency types, for the construction of interpretable ML classifiers for RE. Through a feature engineering effort, in which we are assisted by modern introspection tools that reveal the hidden inner workings of ML classifiers, we derive a set of 17 linguistic features. While classifiers that use our proposed features fit the training set slightly worse than those that use high-dimensional feature sets, our approach performs generally better on validation datasets and it is more interpretable.

Learning requirements engineering (RE) notations is a tedious task for most people, because this learning activity is all but engaging. As an alternative to traditional educational methods, we propose BakeRE, a serious educational game for RE. The game focuses on specific learning objectives: the specification and analysis of requirements with user stories. BakeRE is the first game proposed to address these learning objectives. It is a multilevel puzzle game that can complement courses (traditional or on-line), such as a general software engineering or a specialized RE course. The player assembles user stories for a specific system by combining building blocks (roles, actions, benefits) from a predefined collection. As the player progresses through the levels, the difficulty increases. At the end of each level, learning feedback is provided to the player. Besides describing the game and its learning objectives, we present the game design process and outline in-progress research that aims to extend BakeRE through its embedding within an RE course.

Sociotechnical systems (STSs) are defined by the interaction between technical systems, like software and machines, and social entities, like humans and organizations. The entities within an STS are autonomous, thus weakly controllable, and the environment where the STS operates is highly dynamic. As a result, the design artifacts that represent the requirements of an STS, such as requirements models, may end up being invalid when the system operates, for the autonomous entities do not comply with the requirements, or the environment changes. In this paper, we present a framework that uses runtime execution data to support the runtime validation of requirements models and to guide the evolution of an STS. We propose two types of evolution: (i) manual : the analyst uses Bayesian inference to discover which assumptions in a requirements model are invalid and manually adjusts the system or its model; and (ii) automated : requirements are iteratively revised by an hill climbing algorithm searching for requirements that maximize the achievement of the stakeholders’ objectives. We evaluate the effectiveness of different revision heuristics on a smart traffic simulation applied to an exemplar from the self-adaptive systems literature. The results show that our heuristics, informed by runtime execution data, outperform standard uninformed heuristics, in terms of convergence speed, solution quality, and stability. Moreover, the algorithms show good resilience to noise introduced into the execution data.

Context. Goal models have long been critiqued for the time it takes to construct them as well as for their limited cognitive and visual scalability. Is such criticism general or does it depend on the supported task? Objectives. We advocate for the latter and the aim of this paper is to demonstrate that the next release problem is a suitable application domain for goal models. This hypothesis stems from the fact that product release management is a long-term investment, and software products are commonly managed in "themes" which are smaller focus areas of the product. Methods. We employ a version of goal models that is tailored for the next release problem by capturing requirements, synergies among them, constraints, and release objectives. Such goal model allows discovering optimal solutions considering multiple criteria for the next release. Results. A retrospective case study confirms that goal models are easier to read and comprehend when organized in themes, and that the reasoning results help product managers decide for the next release. Our scalability experiments show that, through reasoning based on optimization modulo theories, the discovery of the optimal solution is fast and scales sufficiently well with respect to the model size, connectivity, and number of alternative solutions.

90% of agile practitioners employ user stories for capturing requirements. Of these, 70% follow a simple template when creating user stories: As aI want to, [so that]. User stories' popularity among practitioners and their simple yet strict structure make them ideal candidates for automatic reasoning based on natural language processing. In our research, we have found that circa 50% of real-world user stories contain easily preventable errors that may endanger their potential. To alleviate this problem, we have created methods, theories and tools that support creating better user stories. This tutorial combines our previous work into a pipeline for working with user stories: (1) The basics of creating user stories, and their use in requirements engineering; (2) How to improve user story quality with the Quality User Story Framework and AQUSA tool; and (3) How to generate conceptual models from user stories using the Visual Narrator and the Interactive Narrator tools. Our toolset is demonstrated with results obtained from 20+ software companies employing user stories.

Special Section on Gamification and Software EngineeringGamification concerns the use of game elements and mechanics in non-gaming contexts.Gamification has been successfully applied to boost certain behaviors and attitudes in many fields including education, healthcare, marketing, management, and recruitment.This theme section is motivated by the observation that the current literature provides little knowledge on the relationship between gamification and software engineering.The call for papers was devised to accommodate two main themes: (i) gamification for software engineering: how can gamification be employed to foster engagement and performance in software engineering?; and (ii) software engineering for gamification: how can the software engineering discipline contribute towards a systematic, and effective, development of gamification applications?There was a very positive response to the call: circa 30 prospective authors contacted us and communicated their intention to submit a paper by sharing a tentative abstract.We discussed thoroughly each case to ensure fitness to scope, and this eventually resulted in a total of 16 within-scope papers which then went through the peer review process.At the end of the process, four papers were accepted to this theme section, while the other 12 were rejected.Most of the non-accepted papers were of good quality, but many had a generic treatment of gamification or did not address the specifics of software engineering.The submitted papers have multidisciplinary foundations, including psychology and economics concepts in relation to perception, behavior, personality, behavior economics and group dynamics.In addition, the papers generally presented an amalgamation between the classic software engineering techniques and activities on one hand, and usability and HCI concepts on the other hand.This reflects well the human-intense nature of gamification and the role of users, better named as subjects, in its acceptance and effectiveness.

Thanks to the advent of interactive technologies, education institutions are looking for innovative teaching methods to increase the engagement and reach of students. Besides the uprise of MOOCs, gamification has been shown to produce positive results when it comes to increasing people's engagement and interest in conducting tasks. Unfortunately, the application and benefits of these technologies in teaching requirements engineering remain largely unexplored. In this paper we introduce the STS-Tooltorial, an interactive gamified platform that executes within a security requirements modeling tool and helps learners apprehend the STS-ml language and basic notions about security requirements. We present the design principles of our functional prototype: its educational content and the embedded game elements. Furthermore, we report on an early evaluation with IT professionals and postgraduate information science students focused on the platform's effectiveness and usability.

Extracting conceptual models from natural language requirements can help identify dependencies, redundancies, and conflicts between requirements via a holistic and easy-to-understand view that is generated from lengthy textual specifications. Unfortunately, existing approaches never gained traction in practice, because they either require substantial human involvement or they deliver too low accuracy. In this paper, we propose an automated approach called Visual Narrator based on natural language processing that extracts conceptual models from user story requirements. We choose this notation because of its popularity among (agile) practitioners and its focus on the essential components of a requirement: Who? What? Why? Coupled with a careful selection and tuning of heuristics, we show how Visual Narrator enables generating conceptual models from user stories with high accuracy. Visual Narrator is part of the holistic Grimm method for user story collaboration that ranges from elicitation to the interactive visualization and analysis of requirements.

Natural language (NL) is still the predominant notation that practitioners use to represent software requirements. Albeit easy to read, NL does not readily highlight key concepts and relationships such as dependencies and conflicts. This contrasts with the inherent capability of graphical conceptual models to visualize a given domain in a holistic fashion. In this paper, we propose to automatically derive conceptual models from a concise and widely adopted NL notation for requirements: user stories. Due to their simplicity, we hypothesize that our approach can improve on the low accuracy of previous works. We present an algorithm that combines state-of-the-art heuristics and that is implemented in our Visual Narrator tool. We evaluate our work on two case studies wherein we obtained promising precision and recall results (between 80% and 92%). The creators of the user stories perceived the generated models as a useful artifact to communicate and discuss the requirements, especially for team members who are not yet familiar with the project.

User stories are a widely adopted requirements notation in agile development. Yet, user stories are too often poorly written in practice and exhibit inherent quality defects. Triggered by this observation, we propose the Quality User Story (QUS) framework, a set of 13 quality criteria that user story writers should strive to conform to. Based on QUS, we present the Automatic Quality User Story Artisan (AQUSA) software tool. Relying on natural language processing (NLP) techniques, AQUSA detects quality defects and suggest possible remedies. We describe the architecture of AQUSA, its implementation, and we report on an evaluation that analyzes 1023 user stories obtained from 18 software companies. Our tool does not yet reach the ambitious 100 % recall that Daniel Berry and colleagues require NLP tools for RE to achieve. However, we obtain promising results and we identify some improvements that will substantially improve recall and precision.

A business process is first and foremost a social interaction among multiple participants. Business process modeling languages support the description of business processes in operational terms, as collections of interleaved activities conducted by human and software agents. However, such descriptions do not capture adequately the richness of social interaction among participants. To address this deficiency, we propose Azzurra, a specification language for modeling and enacting business processes. Azzurra is founded on social concepts, such as roles, agents and commitments among them, and Azzurra specifications are social models consisting of sets of commitments. As such, Azzurra specifications support flexible executions of business processes, and provide a semantic notion of actor accountability and business process compliance. In this paper, we present syntax and semantics of Azzurra, and we propose algorithms to determine runtime compliance with an Azzurra specification.

The Tactical Business Intelligence Model (TBIM) is a language for modeling business tactics. TBIM models act as a bridge between the strategic and tactical organizational levels, for the modeled tactics refine an organization's strategy, while needing further details to become operational. The purpose of TBIM models is to support decision making by representing and enabling the comparison of alternative plans for fulfilling an organization's strategic objectives. In this paper, we report on our experience in applying TBIM for modeling the Montreux Jazz Festival organization case study from the literature. In addition to showing TBIM models for different aspects of festival organization (ticketing and advertising, experience delivery, concerts and recordings), we discuss lessons learned.

Crowdsourcing is an emerging paradigm which utilises the power of the crowd in contributing information and solving problems. Crowdsourcing can support requirements elicitation, especially for systems used by a wide range of users and working in a dynamic context where requirements evolve regularly. For such systems, traditional elicitation methods are typically costly and limited in catering for the high diversity, scale and volatility of requirements. In this paper, we advocate the use of crowdsourcing for requirements elicitation and investigate ways to configure crowdsourcing to improve the quality of elicited requirements. To confirm and enhance our argument, we follow an empirical approach starting with two focus groups involving 14 participants, users and developers, followed by an online expert survey involving 34 participants from the Requirements Engineering community. We discuss our findings and present a set of challenges of applying crowdsourcing to aid requirements engineering with a focus on the elicitation stage.

User stories are a widely used notation for formulating requirements in agile development projects. Despite their popularity in industry, little to no academic work is available on assessing their quality. The few existing approaches are too generic or employ highly qualitative metrics. We propose the Quality User Story Framework, consisting of 14 quality criteria that user story writers should strive to conform to. Additionally, we introduce the conceptual model of a user story, which we rely on to design the AQUSA software tool. AQUSA aids requirements engineers in turning raw user stories into higher-quality ones by exposing defects and deviations from good practice in user stories. We evaluate our work by applying the framework and a prototype implementation to three user story sets from industry.

Sociotechnial systems (STSs) consist of a complex interplay of technical components, humans, and organizations. As other types of systems, STSs need to evolve in response to changing requirements and operational environments. Evolving STSs is a complex activity, which requires reconfiguration of technical components as well as rerouting of interactions among human and social actors. Moreover, reconfiguration has to respect participant autonomy, while coping with conflicting goals and noncooperation in identifying a configuration that minimizes changes relative to the current configuration. In this paper, we present a framework that supports design and evolution of STSs. The framework includes (i) the DEST language for modeling STSs as goal-oriented actors that interact via social commitments; (ii) techniques for building a network of interactions that fulfills participant requirements; and (iii) techniques for evolving an existing STS while minimizing change. We encode the design and evolution of STSs as an automated planning problem.

We address the challenge of requirements engineering for sociotechnical systems, wherein humans and organizations supported by technical artifacts such as software interact with one another. Traditional requirements models emphasize the goals of the stakeholders above their interactions. However, the participants in a sociotechnical system may not adopt the goals of the stakeholders involved in its specification. We motivate, Protos, a requirements engineering approach that gives prominence to the interactions of autonomous parties and specifies a sociotechnical system in terms of its participants' social relationships, specifically, commitments. The participants can adopt any goal they like, a key basis for innovative behavior, as long as they interact according to the commitments. Protos describes an abstract requirements engineering process as a series of refinements that seek to satisfy stakeholder requirements by incrementally expanding a specification set and an assumption set, and reducing requirements until all requirements are accommodated. We demonstrate this process via the London Ambulance System described in the literature.

In this position paper we review the history of requirements models and conclude that a goal-oriented perspective offers a suitable abstraction for requirements analysis. We stake positions on the nature of modelling languages in general, and requirements modelling languages in particular. We then sketch some of the desirable features (... “requirements”) of design-time and runtime requirements models and draw conclusions about their similarities and differences.

Goal models capture stakeholder requirements for a system-to-be, but also circumscribe a space of alternative specifications for fulfilling these requirements. Recent proposals for self-adaptive software systems rely on variants of goal models to support monitoring and adaptation functions. In such cases, goal models serve as mechanisms in terms of which systems reflect upon their requirements during their operation. We argue that existing proposals for using goal models at runtime are using design artifacts for purposes they were not intended, i.e., for reasoning about runtime system behavior. In this paper, we propose a conceptual distinction between Design-time Goal Models (DGMs)-used to design a system-and Runtime Goal Models (RGMs)-used to analyze a system's runtime behavior with respect to its requirements. RGMs extend DGMs with additional state, behavioral and historical information about the fulfillment of goals. We propose a syntactic structure for RGMs, a method for deriving them from DGMs, and runtime algorithms that support their monitoring.

Security Requirements Engineering (SRE) deals with the elicitation and analysis of security needs to specify security requirements for the system-to-be. In previous work, we have presented STS-ml, a security requirements modelling language for Socio-Technical Systems (STSs) that elicits security needs, using a goal-oriented approach, and derives the security requirements specification based on these needs. Particularly, STS-ml relates security to the interaction among actors in the STS. In this paper, we present STS-Tool, the modelling and analysis support tool for STS-ml. STS-Tool allows designers to model a STS at a high-level of abstraction, while expressing security needs over the interactions between the actors in the STS, and derive security requirements in terms of social commitments - promises with contractual validity - once the modelling is done.