AI-driven recruitment systems offer potential benefits in improving hiring efficiency and reach. However, without explicit attention to inclusivity, these systems risk perpetuating historical biases and reinforcing systemic inequalities. While ethical guidelines for inclusive AI exist, organisations face challenges in operationalising them, particularly in complex, real-world settings like online employment platforms. This paper investigates how inclusive design principles, grounded in diversity and inclusion guidelines, can be translated into requirements for AI-driven recruitment systems. We partnered with SEEK, a leading employment marketplace in the Asia-Pacific region, to conduct a co-design workshop focused on identifying and contextualising inclusivity requirements from AI-based hiring use cases. Using requirements engineering techniques of user stories, personas, and stakeholder reflection, we explored two use cases and conducted follow-up interviews six months later to evaluate the impact and sustainability of these efforts. Our findings reveal challenges in aligning inclusivity with business priorities, navigating trade-offs, and addressing data limitations. We present industry-informed lessons on how requirements engineering can support the operationalisation of inclusive AI principles, offering guidance for practitioners aiming to embed diversity and inclusion principles in AI systems. This work contributes to integrating ethical design into AI development lifecycles through stakeholder-driven requirements processes.

Abstract The convergence of Quantum Computing (QC), Quantum Software Engineering (QSE), and Artificial Intelligence (AI) presents transformative opportunities across various domains. However, existing methodologies inadequately address the ethical, security, and governance challenges arising from this technological shift. This paper highlights the urgent need for interdisciplinary collaboration to embed ethical principles into the development of Quantum AI (QAI) and QSE, ensuring transparency, inclusivity, and equitable global access. Without proactive governance, there is a risk of deepening digital inequalities and consolidating power among a select few. We call on the software engineering community to actively shape a future where responsible QSE and QAI are foundational for ethical, accountable, and socially beneficial technological progress.

The rapid expansion of Artificial Intelligence (AI) technologies has introduced both significant advancements and challenges, with diversity and inclusion (D&I) emerging as a critical concern. Addressing D&I in AI is essential to reduce biases and discrimination, enhance fairness, and prevent adverse societal impacts. Despite its importance, D&I considerations are often overlooked, resulting in incidents marked by built-in biases and ethical dilemmas. Analyzing AI incidents through a D&I lens is crucial for identifying causes of biases and developing strategies to mitigate them, ensuring fairer and more equitable AI technologies. However, systematic investigations of D&I-related AI incidents are scarce. This study addresses these challenges by identifying and understanding D&I issues within AI systems through a manual analysis of two AI incident databases, AI Incident Database (AIID) and AI, Algorithmic, and Automation Incidents and Controversies (AIAAIC). The research develops a decision tree to investigate D&I issues tied to AI incidents and populate a public repository of D&I-related AI incidents. The decision tree was validated through a card sorting exercise and focus group discussions. The research demonstrates that almost half of the analyzed AI incidents are related to D&I, with a notable predominance of racial, gender, and age discrimination. The decision tree and resulting public repository aim to foster further research and responsible AI practices, promoting the development of inclusive and equitable AI systems.

To complement the manual contact-tracing methods, a flood of coronavirus-related apps was launched in the first half of 2020. Despite the incredible promises made by the governments, contact-tracing apps did not live up to expectations. We provide a contextual perspective of the government commissioned contact-tracing apps from four countries to understand the non-functional requirements (NFRs) and socio-technical factors that hindered the success of these apps. We collected the user reviews from the app stores for iOS and Android versions and identified top news articles related to each app. Our analysis revealed that the dominant factors behind the negligible success of these apps are complex and entangled with the cultural and political dimensions rather than being just technical. The multilayer diversity of the target users also impacted the design and development of contact-tracing apps in an extremely challenging situation. This perspective paper brings into light important elements, such as politics and socio-cultural aspects that should be studied in the design of contact-tracing apps, and public apps in general.

The core aim of requirements inspection is to ensure the high quality of already elicited requirements in the Software Requirements Specification. Teaching requirements inspection to novices is challenging, as inspecting requirements needs several skills as well as knowledge of the product and process that is hard to achieve in a classroom environment. Published studies about pedagogical design specifically for teaching requirements inspection are scarce. Our objective is to present the design and evaluation of a postgraduate course for requirements inspection training. We conducted an empirical study with 138 postgraduate students, teamed up in 34 groups to conduct requirements inspection. We performed qualitative analysis on the data collected from students' reflection reports to assess the effects of the pedagogical design in terms of benefits and challenges. We also quantitatively analyze the correlation between the students' performance in conducting inspections and their ability of writing specifications. From the analysis of students' reflections, several themes emerged such as their difficulty of working with limited information, but also revealed the benefits of learning teamwork and writing good requirements. This qualitative analysis also provides recommendations for improving the related activities. The results revealed a moderate positive correlation between the performance in writing specification and inspection.

IoT (Internet of Things) platforms are key enablers for smart city initiatives, targeting the improvement of citizens’ quality of life and economic growth. As IoT platforms are dynamic, proactive, and heterogeneous socio-technical artefacts, systematic approaches are required for their development. Limited surveys have exclusively explored how IoT platforms are developed and maintained from the perspective of information system development process lifecycle. In this paper, we present a detailed analysis of 63 approaches. This is accomplished by proposing an evaluation framework as a cornerstone to highlight the characteristics, strengths, and weaknesses of these approaches. The survey results not only provide insights of empirical findings, recommendations, and mechanisms for the development of quality aware IoT platforms, but also identify important issues and gaps that need to be addressed.

In many software development projects, analysts are required to deal with systems' requirements from unfamiliar domains. Familiarity with the domain is necessary in order to get full leverage from interaction with stakeholders and for extracting relevant information from the existing project documents. Accurate and timely extraction and classification of requirements knowledge support analysts in this challenging scenario. Our approach is to mine real-time interaction records and project documents for the relevant phrasal units about the requirements related topics being discussed during elicitation. We propose to use both generative and discriminating methods. To extract the relevant terms, we leverage the flexibility and power of Weighted Finite State Transducers (WFSTs) in dynamic modelling of natural language processing tasks. We used an extended version of Support Vector Machines (SVMs) with variable-sized feature vectors to efficiently and dynamically extract and classify requirements-related knowledge from the existing documents. To evaluate the performance of our approach intuitively and quantitatively, we used edit distance and precision/recall metrics. We show in three case studies that the snippets extracted by our method are intuitively relevant and reasonably accurate. Furthermore, we found that statistical and linguistic parameters such as smoothing methods, and words contiguity and order features can impact the performance of both extraction and classification tasks.

Interviews are largely used in the practice of requirements elicitation. Nevertheless, performing an effective interview often depends on soft-skills, and on knowledge acquired through experience. When it comes to requirements engineering education and training (REET), limited resources and few well-founded pedagogical approaches are available to allow students to acquire and improve their skills as interviewers. This paper presents a novel pedagogical approach that combines role-playing, peer-review and self-assessment to enable students to reflect on their mistakes, and improve their interview skills. We evaluate the approach through a controlled quasi-experiment. The study shows that the approach significantly reduces the amount of mistakes made by the students. Feedback from the participants confirms the usefulness and easiness of the proposed training. This work contributes to the body of knowledge of REET with an empirically evaluated method for teaching inter-views. Furthermore, we share the pedagogical material used, to enable other educators to apply and possibly tailor the approach.

In the constantly evolving world of software development, switching back and forth between tasks has become the norm. While task switching often allows developers to perform tasks effectively and may increase creativity via the flexible pathway, there are also consequences to frequent task-switching. For high-momentum tasks like software development, "flow", the highly productive state of concentration, is paramount. Each switch distracts the developers' flow, requiring them to switch mental state and an additional immersion period to get back into the flow. However, the wasted time due to time fragmentation caused by task switching is largely invisible and unnoticed by developers and managers. We conducted a survey with 141 software developers to investigate their perceptions of differences between task switching and task interruption and to explore whether they perceive task switchings as disruptive as interruptions. We found that practitioners perceive considerable similarities between the disruptiveness of task switching (either planned or unplanned) and random interruptions. The high level of cognitive cost and low performance are the main consequences of task switching articulated by our respondents. Our findings broaden the understanding of flow change among software practitioners in terms of the characteristics and categories of disruptive switches as well as the consequences of interruptions caused by daily meetings.

[CONTEXT] Involving users in software development is a complex and multi-faceted concept. Empirical research that studies power and politics of user involvement in software development is scarce. [OBJECTIVE] In this paper, we present the results from a case study of a software development project, where organizational politics was explored in context of user involvement in software development. [METHOD] We collected data through 30 interviews with 20 participants, attending workshops, observing project meetings, and analysing projects documents. The qualitative data was rigorously and iteratively analyzed. [RESULTS] The results indicate that the politics was a significant factor used to exert power and influence in decision-making processes. Communication channels were exploited for political purposes. These contributed to the users' dissatisfaction with their involvement thus impacting on the project outcome. [CONCLUSION] Having multiple teams of stakeholders with different levels of power in decision-making, the politics is inevitable and inescapable. Without careful attention, the political aspect of user involvement in software development can contribute to unsuccessful project.

Requirements elicitation can be very challenging in projects that require deep domain knowledge about the system at hand. As analysts have the full control over the elicitation process, their lack of knowledge about the system under study inhibits them from asking related questions and reduces the accuracy of requirements provided by stakeholders. We present ELIC, a generic interactive visual analytics tool to assist analysts during requirements elicitation process. ELICA uses a novel information extraction algorithm based on a combination of Weighted Finite State Transducers (WFSTs) (generative model) and SVMs (discriminative model). ELICA presents the extracted relevant information in an interactive GUI (including zooming, panning, and pinching) that allows analysts to explore which parts of the ongoing conversation (or specification document) match with the extracted information. In this demonstration, we show that ELICA is usable and effective in practice, and is able to extract the related information in real-time. We also demonstrate how carefully designed features in ELICA facilitate the interactive and dynamic process of information extraction.

[Context] Interviews are the most widely used elicitation technique in requirements engineering. However, conducting effective requirements elicitation interviews is challenging, due to the combination of technical and soft skills that requirements analysts often acquire after a long period of professional practice. Empirical evidence about training the novices on conducting effective requirements elicitation interviews is scarce. [Objectives] We present a list of most common mistakes that novices make in requirements elicitation interviews. The objective is to assist the educators in teaching interviewing skills to student analysts. [Re-search Method] We conducted an empirical study involving role-playing and authentic assessment with 110 students, teamed up in 28 groups, to conduct interviews with a customer. One re-searcher made observation notes during the interview while two researchers reviewed the recordings. We qualitatively analyzed the data to identify the themes and classify the mistakes. [Results and conclusion] We identified 34 unique mistakes classified into 7 high level themes. We also give examples of the mistakes made by the novices in each theme, to assist the educationists and trainers. Our research design is a novel combination of well-known pedagogical approaches described in sufficient details to make it re-peatable for future requirements engineering education and training research.

Context: User involvement is generally considered to contributing to user satisfaction and project success and is central to Agile software development. In theory, the expectations about user involvement, such as the PO's, are quite demanding in this Agile way of working. But what are the expectations seen in practice, and are the expectations of user involvement aligned among the development team and users? Any misalignment could contribute to conflict and miscommunication among stakeholders that may result in ineffective user involvement. Objective: Our aim is to compare and contrast the expectations of two stakeholder groups (software development team, and software users) about user involvement in order to understand the expectations and assess their alignment. Method: We have conducted an exploratory case study of expectations about user involvement in an Agile software development. Qualitative data was collected through interviews to design a novel method for the assessing the alignment of expectations about user involvement by applying Repertory Grids (RG). Results: By aggregating the results from the interviews and RGs, varying degrees of expectation alignments were observed between the development team and user representatives. Conclusion: Alignment of expectations can be assessed in practice using the proposed RG instrument and can reveal misalignment between user roles and activities they participate in Agile software development projects. Although we used RG instrument retrospectively in this study, we posit that it could also be applied from the start of a project, or proactively as a diagnostic tool throughout a project to assess and ensure that expectations are aligned.

Context and Motivation Natural language processing has been used since the 1980s to construct tools for performing natural language (NL) requirements engineering (RE) tasks. The RE field has often adopted information retrieval (IR) algorithms for use in implementing these NL RE tools. Problem Traditionally, the methods for evaluating an NL RE tool have been inherited from the IR field without adapting them to the requirements of the RE context in which the NL RE tool is used. Principal Ideas This panel discusses the problem and considers the evaluation of tools for a number of NL RE tasks in a number of contexts. Contribution The discussion is aimed at helping the RE field begin to consistently evaluate each of its tools according to the requirements of the tool's task.

In requirements elicitation interviews, ambiguities identified by analysts can help to disclose the tacit knowledge of customers. Indeed, ambiguities might reveal implicit or hard to express information that needs to be elicited. The perception of ambiguity might depend on the subject who is acting as analyst, and different analysts might identify different ambiguities in the same interview. Based on this intuition, we propose to investigate the difference between ambiguities explicitly revealed by an analyst during a requirements elicitation interview, and ambiguities annotated by a reviewer who listens to the interview recording, with the objective of defining a method for interview review. We performed an exploratory study in which two subjects listened to a set of customer-analyst interviews. Only in 26% of the cases the ambiguities revealed by the analysts matched with the ambiguities found by the reviewers. In 46% of the cases, ambiguities were found by the reviewers, and were not detected by the analysts. Based on these preliminary findings, we are currently performing a controlled experiment with students of two universities, which will be followed by a real-world case study with companies. This paper discusses the current results, together with our research plan.

Software has always been considered as malleable. Changes to software requirements are inevitable during the development process. Despite many software engineering advances over several decades, requirements changes are a source of project risk, particularly when businesses and technologies are evolving rapidly. Although effectively managing requirements changes is a critical aspect of software engineering, conceptions of requirements change in the literature and approaches to their management in practice still seem rudimentary. The overall goal of this study is to better understand the process of requirements change management. We present findings from an exploratory case study of requirements change management in a globally distributed setting. In this context we noted a contrast with the traditional models of requirements change. In theory, change control policies and formal processes are considered as a natural strategy to deal with requirements changes. Yet we observed that "informal requirements changes" (InfRc) were pervasive and unavoidable. Our results reveal an equally 'natural' informal change management process that is required to handle InfRc in parallel. We present a novel model of requirements change which, we argue, better represents the phenomenon and more realistically incorporates both the informal and formal types of change.

Context: The benefits of involving users in software development projects have been studied extensively in the last four decades and have been reported to contribute to user satisfaction thus leading to system success. However, the relationship between user involvement and system success, being a multi-faceted and complex concept, has introduced many problems and challenges for the practitioners. Objective: In this paper we present our findings from a case study to give a deeper understanding of the challenges and problems of user involvement during software development. Method: The data in the case study was collected from interviews, observations and project documents. Results: We present our results in four main categories related to users, communicative aspects, managerial considerations, and project issues. It was observed that system success is achievable even when there are problems and challenges in involving users. Conclusion: Understanding the nature of the problems related to user involvement helps the project managers to develop appropriate strategies for increasing the effectiveness of user involvement.

Traceability among requirements artifacts (and beyond, in certain cases all the way to actual implementation) has long been identified as a critical challenge in industrial practice. Manually establishing and maintaining such traces is a high-skill, labour-intensive job. It is often the case that the ideal person for the job also has other, highly critical tasks to take care of, so offering semi-automated support for the management of traces is an effective way of improving the efficiency of the whole development process. In this paper, we present a technique to exploit the information contained in previously defined traces, in order to facilitate the creation and ongoing maintenance of traces, as the requirements evolve. A case study on a reference dataset is employed to measure the effectiveness of the technique, compared to other proposals from the literature.

Though the primary goal of requirements engineering research is to propose, develop, and validate effective solutions for important practical problems, practice has shown that successful projects take from 20–25 years to reach full industry adoption, while many projects fade and never advance beyond the initial research phase. In this interactive panel, teams of researchers, representing different requirements engineering research areas, bring ideas for technology transfer to a panel of industrial and government practitioners. The teams make interactive presentations and receive feedback from panelists. Beneath the game-show genre of the panel is the serious goal to foster conversation between practitioners and researchers to improve the effectiveness of technology transfer in the requirements engineering community.

Context: In the last four decades involving users in the software development process is claimed to have a positive impact on the success of that software. However, previous reviews on this topic have produced conflicting results. Objectives: Our aim is to present a review on user involvement in software development process and investigate its relationship to software system success. Methods: For our exploration, we performed a Systematic Literature Review using the guidelines provided in the Evidence Based Software Engineering literature. Results: 87 relevant empirical studies were selected and reviewed that investigate various perspectives and concepts of user involvement in software development process during the period of 1980--2012. Among 87 studies reviewed, 59 report that user involvement positively contributes to system success, 7 suggest a negative contribution and 21 are uncertain. Conclusions: Our results show an overall positive impact of user involvement on system success. It also suggests that the relationship between user involvement and system success is neither direct nor simple, and it depends on many different factors and conditions surrounding systems development processes.

Prior studies reveal that conflicts among Non Functional Requirements (NFRs) are not always absolute. They can also be relative depending on the context of the system being developed. Given that existing techniques to manage the NFRs conflicts are mainly focused on cataloguing the interrelationships among various types of NFRs, hence a technique to manage the NFRs conflicts with respect to NFRs relative characteristic is needed. This paper presents a novel framework to manage the conflicts among NFRs with respect to NFRs relative characteristic. By applying an experimental approach, the quantitative evidence of NFRs conflicts will be obtained and modeled. NFRs metrics and measures will be used in the experiments as parameters to generate the quantitative evidence. This evidence can then allow developers to identify and reason about the NFRs conflicts. We also provide an example of how this framework could be applied.

Reasoning is critical for non-functional requirements (NFRs) analysis and verification. Furthermore, it can provide rationale about implementation strategies for NFRs. The existing tools can execute an interactive reasoning process which sometimes needs extra information from stakeholders. We build a tool called rΣ for reasoning on NFR models especially when extra information is unavailable or forbidden, like at the model verification stage. This tool employs the formula style model as the input, automatically promotes the reasoning process till the root node, and returns all the satisficing statuses and the complete rationale as the output. We have applied rΣ into the real practice and to evaluate its efficiency.

Software development is a dynamic process where demands for change have been recognized to be inevitable. All forms of modifications to the user requirements cause software to change. The sources of changes could vary considerably and come from the users, business, technology, and organizations. Changes to requirements give rise to an intrinsic volatility, which is claimed to impact on many aspects of software development. Requirements Volatility (RV) is claimed to be a major source of risk to the management of software projects. Investigating the sources of, reasons for, and impacts of requirements changes is an important prerequisite for understanding the characteristics of requirements volatility. In this talk, I will discuss the nature of requirements changes and describe the results of our longitudinal study of requirements volatility. The results of this study have improved our understanding of this complex and multifaceted phenomenon and have provided valuable empirical evidence for the impacts of RV resulting in important insights for more effective management of requirements.

Software requirements, especially non-functional requirements, are considered as vital prerequisites for producing software of high quality. As widely accepted, non-functional goal modeling like the NFR Framework usually employs tree modeling style, and presents an interactive process for the analysis of nonfunctional requirements. However, there still exist some problems during the identification of satisficing status. This paper based on the popular NFR goal model reasoning manners, clearly distinguishes the closed world assumption and the open world assumption, and proposes an automatic reasoning mechanism for NFR goal models in order to identify the satisficing statuses of the goal tree roots according to leaves' contributions. Under a specific assumption, goals' satisficing statuses will be transformed to affect satisficing statuses of their parents. Then parents'satisficing statuses will be inferred according to the reasoning rules derived from different decomposition relationships. By alternately adopting these two steps, goal tree root's satisficingstatus can be identified layer by layer. An illustrative example is used to show how our proposed formal approach works.

Software development is inherently an ordering process. When implemented in a workplace it orders the ways that people go about their work, the work they do, and the ways they interact and communicate with each other. This new mode of ordering may conflict with existing orders, existing distributions of power and knowledge, and arrangements of groups, and between groups. Ordering is almost always the subject of dispute, so software development can easily become enmeshed in the politicking between competing groups with deleterious effects. Removing all these conflicts may not be possible, as they can be an essential part of the ways relevant groups interact. Better communication, for example, may actually increase conflict, and not produce harmony. Rather than thinking of order and disorder as mutually exclusive polarities, it is more effective and realistic to think of them as constituting an `order/disorder complex' and to expect disorder to appear alongside the ordering. This paper explores the problems of ordering and disordering through a study of changes in the Australian Customs' “Integrated Cargo System”. We suggest that acceptance of some untidied mess, or openness to both dispute and unclarity, may be useful in implementing functional software.

In the Problem Frames (PF) approach there are five basic problem frames and some variants to them. When a problem is being analysed, it is initially matched against these frames. If the problem does not fit into the basic problem frames or their variants, then problem analysis is performed. It has been recognised that `projection' is an effective technique for analysing problems. That is, each sub-problem is considered as a projection of the main problem concerned only with the phenomena relevant to that sub-problem. The PF approach lacks a precise definition of problem projection and does not provide specific instructions on how to perform this projection. In this paper, we use the concept of projection from relational algebra and combine it with concepts from the PF and scenario-based approaches to present a conceptual model for conducting problem projection in requirements engineering. This model and ontology extend problem description at scenario level and support systematic derivation of sub-problems from scenarios. We also provide a detailed process description for performing projection for problem analysis and present the utility of our approach with a case study.

Academics and practitioners alike have long recognized the key challenges of requirements engineering education and training. This panel attempts to discuss these key challenges in details and provide an opportunity for a meaningful dialogue between academics and practitioners for identifying effective pedagogical paradigms, practical techniques and tools for teaching and learning requirements engineering principles.

Inconsistency is a pervasive issue in software engineering. Both general rules of inconsistency management and special case-based approaches to handling inconsistency have recently been considered. In this paper, we present a process model for handling requirements inconsistency within the viewpoints framework. In this process model, when an inconsistency among viewpoints is detected, a set of candidate proposals for handling inconsistency will be generated using techniques from multi-agent automated negotiations. The proposals are then prioritized using an integrated measurement of inconsistencies. The viewpoints involved in the inconsistency will then enter the negotiations by being presented with the candidate proposals and thus selecting an acceptable proposal based on the priorities associated with each candidate proposal. To facilitate usability, in our process, we assume that the natural language requirements statements are first translated into corresponding logical formulas using a translator software. Moreover, the candidate proposals for handling inconsistency are also translated back from formal logic into natural language before being presented for selection.

Numerous studies have shown that a software projectpsilas cost, schedule and defect density escalate as the rate of requirements change increases. Yet none of these studies have explored the effects of not making requirements changes in response to changes in user needs. This paper explains why a project incurs just as much, if not more, risk when requirements changes are suppressed.

In this panel, we propose to figure out how requirements engineering and interaction design can be usefully combined. In particular, some people argue that scenarios/ use cases should be concrete, as in story-telling. Others argue for use of "essential" use cases as a methodological approach to interaction and user-interface design. Somewhat in the middle, it is argued that use cases should help acquiring the requirements in the first place. What should the practitioner believe and, in particular, do, in order to develop useful and usable software and systems? Software development and interaction design require different skills and different methods and are typically done by different people. Still, scenario-based design is proposed for several activities relevant for both tasks, such as requirements elicitation, software design, and interaction design. Symbolic modeling in this spirit is actually common to various fields. However, scenario-based approaches vary, especially with regard to their use, e.g., employing abstract use cases or integrating scenarios with functions and goals in a systematic design process. So, the key issue to be raised at the panel is how to combine different approaches, e.g., in scenario-based development, so that the interaction design as well as the development of the user interface and of the software internally result in an overall useful and useable system.

This panel presents and discusses effective techniques for teaching requirements engineering principles and practices, in ways which actively engage students in the learning process.

Increasingly, IT systems and Web systems in particular, fall into the class of applications where the scope of the application to be developed cannot be clearly articulated a priori. This is for a range of reasons, but is at least in part due to the complex inter-dependencies which exist between different aspects of the problem domain. While Whereas the core system requirements might be clear, the domain inter-dependencies lead to ancillary requirements which are only identified as the emerging system and its relationship to the domain are understood. A key mechanism in supporting the development of this understanding is the exploration of application pilots or prototypes, and the subsequent identification of solution or problem domain issues. The resolution of these issues will often play a crucial role in supporting the development of domain understanding and hence project scope. In this paper we explore this phenomenon by analysing issue handling across a range of case studies. We describe a model of the issue resolution process and highlight those issues which are most likely to assist in clarification of project scope.

It has been suggested that constraining a natural language (NL) reduces the degree of ambiguity of requirement specifications written in that language. There is also a tendency to assume that an inescapable side effect of constraining a natural language is a subsequent reduction in its expressiveness. The primary objective of this paper is to describe a technique that we have developed for empirically measuring the expressiveness of a constrained natural language (CNL) when used to specify the requirements in a particular application domain. Our simple yet practical and repeatable technique elucidates the individual contribution that each lexical entity of the CNL can make on the overall expressiveness of the CNL This technique is particularly useful for designing new CNLs, as well as situations where tailoring or streamlining existing CNLs for particular application domains is needed.

The use of logic in identifying and analyzing inconsistency in requirements from multiple stakeholders has been found to be effective in a number of studies. Nonmonotonic logic is a theoretically well-founded formalism that is especially suited for supporting the evolution of requirements. However, direct use of logic for expressing requirements and discussing them with stakeholders poses serious usability problems, since in most cases stakeholders cannot be expected to be fluent with formal logic. In this article, we explore the integration of natural language parsing techniques with default reasoning to overcome these difficulties. We also propose a method for automatically discovering inconsistencies in the requirements from multiple stakeholders, using both theorem-proving and model-checking techniques, and show how to deal with them in a formal manner. These techniques were implemented and tested in a prototype tool calledCARL. The effectiveness of the techniques and of the tool are illustrated by a classic example involving conflicting requirements from multiple stakeholders.

This paper outlines existing maturity models of project management and their underlying constructs. Organizations involved in software development in Sydney, Australia were interviewed about their project management practices and their responses analysed to determine whether different project managers used different levels of project management practices and whether the practices were in accordance with a process based maturity model. This did not seem to be the case, yet the data suggested that, as a possible alternative, a systems theory based approach might be more tenable. The overall conclusion, that a system theory based maturity model appears to be better correlated with organizational size and software development maturity than a process based maturity model, is briefly discussed and additional research is suggested that could investigate this novel conclusion further.

Requirements engineering (RE) has attracted a great deal of attention from researchers and practitioners in recent years. This increasing interest demands academia to provide software engineering students with a solid foundation in the subject matter. RE is a multi disciplinary and communication rich activity in software development. The RE tools, methods and techniques to date have drawn upon a variety of disciplines, and the requirements engineers are increasingly expected to be well versed with these disciplines. In RE education, it is thus imperative to cover a wide range of topics and teach a variety of skills that one needs to know and acquire to be able to perform effective requirements engineering. We argue that in teaching RE, we must cover three fundamental topics: the traditional analysis and modelling skills, interviewing and groupware skills for requirements elicitation, and writing skills for specifying requirements. We report on our experiences gained in teaching such a requirements engineering subject for the first time to students at University of Technology, Sydney. We used role playing as a pedagogical tool to give students a greater appreciation of the range of issues and problems associated with requirements engineering in real settings. We believe that the lessons learnt from this exercise will be valuable for those interested in advancing requirements engineering education and training.

Software development is considered to be a dynamic process where demands for changes seem to be inevitable. Modifications to software are prompted by all kinds of changes including changes to the requirements. This type of changes gives rise to an intrinsic volatility, which has several impacts on the software development lifecycle. This paper describes our findings of an extensive survey based empirical study of requirement volatility (RV) and its impact on software project performance. In particular, findings reveal that requirement volatility has a significant impact on schedule overrun and cost overrun in software projects. Our investigation also examined factors that contribute to the extent of requirement volatility and found that variables such as frequent communications between users and developers and usage of a definable methodology in requirements analysis and modeling have impact on the stability of requirements.

The increasing globalization of software industry demands an investigation of requirements engineering (RE) in multisite software development organizations. Requirements engineering is a task difficult enough when done locally-but it is even more difficult when cross-functional stakeholder groups specify requirements across cultural, language and time zone boundaries. This paper reports on a field study that investigated RE challenges introduced by stakeholders' geographical distribution in a multi-site organization. The goal was to examine RE practice in global software development, to formulate recommendations for improvement as well as to provide directions for future research on methods and tools. Based on the empirical evidence, we have constructed a model of how remote communication and knowledge management, cultural diversity and time differences negatively impact on requirements gathering, negotiation and specification. Findings reveal that aspects such as a lack of a common understanding of requirements, together with reduced awareness of working local context, trust level and ability to share work artifacts significantly challenge the effective collaboration of remote stakeholders in negotiating a set of requirements that satisfies geographically distributed customers. The paper concludes with recommendations for improving RE practice in this setting.

The use of logic in identifying and analysing inconsistency in requirements from multiple stakeholders has been found to be effective in a number of studies. Default reasoning is a theoretically well founded formalism that is especially suited for supporting the evolution of requirements. However, direct use of logic in eliciting requirements and in discussing them with stakeholders poses serious useability problems. In this paper we explore the integration of natural language parsing techniques with default reasoning to overcome these difficulties. We also propose a method for automatically discovering scenarios that expose inconsistencies in requirements, and show how to deal with them in a formal manner. These techniques were implemented and tested in a prototype tool called CARL.

We present a logical framework for modeling and reasoning about the evolution of requirements. We demonstrate how a sufficiently rich meta level logic can formally capture intuitive aspects of managing changes to requirements models, while maintaining completeness and consistency. We consider a theory as the deductive closure of a given set of axioms and conclude that software engineering is concerned, in essence, with, building and managing large theories. This theory construction commences with the development of the requirements model which we view as a theory of some nonmonotonic logic. Requirements evolution then involves the mapping of one such theory to another. Exploiting the deductive power of the theory of belief revision and nonmonotonic reasoning we develop a formal description of this mapping, as well as the requirements engineering process itself. This work thus offers a rigorous approach to reasoning about requirements evolution and a important focus for defining semantically well founded methods and tools for the effective management of changing requirements.