[Context]. Requirements Process Debt (RPD) refers to shortcomings or inefficiencies in the requirements engineering process. Through an industry-wide survey, the InsighTD project identified the causes of RPD, its effects, and practices for its prevention and mitigation. Another approach to exploring RPD is by examining grey literature (GL), i.e., sources that have not been formally published. One such source is the discourse of solution providers, a specific type of web content. Although this discourse can enhance the knowledge gained through empirical studies, no research has yet explored it. [Aims]. To investigate how public discourse has discussed the causes of RPD. [Research Method]. We elicited public discourse on RPD causes using predefined search strings on Google and Bing. We collected web addresses where discussions on RPD causes were found and applied content analysis procedures to examine the data. [Results]. Based on public discourse, we produced 128 codes for causes, 60 for effects of RPD, along with 93 preventive and 70 mitigation practices. These elements were categorized to reveal their relationships within the software development process. [Conclusion]. Our study expands the body of knowledge on RPD causes, demonstrating that GL can serve as a valuable complementary source.

[Context & Motivation] Satisficing Explainability, as a Non-Functional Requirement, is posed to be an increasing social demand. [Question/Problem] Exploring how this quality should be amalgamated into software production is a new avenue of research. [Principal ideas/Results] Using the perspective of intentional modeling, we performed a first probe of challenges for the design of a futuristic kitchen. [Contribution] This paper targets challenges for building socially responsible software by exploring the modeling of ffituristic systems from the point of view of Non-Functional Requirements, in particular of Explainability.

The ubiquitous presence of software in the products we use, together with Artificial Intelligence in these products, has led to an increasing need for consumer trust. Consumers often lose faith in products, and the lack of Trust propagates to the companies behind them. This is even more so in mission-critical systems such as autonomous vehicles and clinical support systems. This paper follows grounded theory principles to elicit knowledge related to Trust, Ethics, and Transparency. We approach these qualities as Non-Functional Requirements (NFRs), aiming to build catalogs to subsidize the construction of Socially Responsible Software. The corpus we have used was built on a selected collection of literature on Corporate Social Responsibility, with an emphasis on Business Ethics. Our challenge is how to encode the social perspective knowledge, mainly through the view of Corporate Social Responsibility, on how organizations or institutions achieve trustworthiness. Since our ground perspective is that of NFRs, results are presented by a catalogue of Trust as a Non-Functional Requirement, represented as a Softgoal Interdependency Graph (SIG). The SIG language helps software engineers in understanding alternatives they have to improve Trust in software products.

Self-Driving cars is a fast-growing area of study both in academia and industry. It is part of a broader domain which involves the development of software for Highly Automated Vehicles (HAV) and notions extracted from Artificial Intelligence/Autonomous Systems (AI/AS). There are many challenges that must be overcome to deliver self-driving cars in a manner that is readily accepted by consumers and society. Studies have shown that although many people are comfortable with the idea of AI helping them to operate their houses or schedule appointments, not many people are comfortable with the idea of cars being driven by AI algorithms. At the same time, insurance companies are concerned about vehicle liability issues and how to demonstrate who/what caused an accident. We believe that self-driving cars that demonstrate transparency in their operations will increase consumer trust which is pivotal to its acceptance and will pave the way for its commercialization and daily use. In this work, we investigate how to pursue the elicitation and modeling of transparency as a Non-Functional Requirement (NFR) to produce self-driving cars that are more robust.

Laws and regulations impact the design of software systems, as they may introduce additional requirements and possible conflicts with pre-existing requirements. We propose a systematic, tool-supported process for establishing compliance of a software system with a given law. The process elicits new requirements from the law, compares them with existing ones and manages conflicts, exploiting a set of heuristics, partially supported by a tool. We illustrate our proposal through an exploratory study using the Italian Privacy Law. We also present results of a preliminary empirical study that indicates that adoption of the process improves compliance analysis for a simple compliance scenario.

This work presents a pedagogical proposal, in the context of game-based learning (GBL), that uses the concept of Transparency Pedagogy. As such, it aims to improve the quality of teaching, and the relationship between student, teacher and teaching methods. Transparency is anchored in the principle of information disclosure. In pedagogy, transparency emerges as an important issue that proposes to raise student awareness about the educational processes. Using GBL as an educational strategy we managed to make the game, a software, transparent. That is we made the inner processes of the game known to the students. As such, besides learning by playing, students had access to the game design, through intentional modeling. We collected evidence that, by disclosure of the information about the design, students better performed on learning software engineering.

Estimating the size of a software system is a critical task due to the implications the estimation has in the management of the development project. There are some widely accepted estimation techniques: Function Points, Use Case Points and Cosmic Points, but these techniques can only be applied after the availability of a requirements specification. In this paper, we propose an approach to estimate the size of an application previous to its requirements specification by using the application language itself, captured by the Language Extended Lexicon (LEL). Our approach is based on Use Case Points and on a technique which derives Use Cases from the LEL. The proposed approach provides a measure of the application's size earlier than the usual techniques, thus reducing the effort needed to apply them. An initial experiment was conducted to evaluate the proposal.

This work presents an educational board and card game named SimulES-W, as a tool for teaching Software Engineering. It encompasses 5 years of evolution, in which the game Problems and Programmers was the fundamental source. SimulES-W innovates in three distinct areas: it is a web based game, it relies on a broad view of the software process and it is customizable for content. SimulES-W is supported by collaborative software that implements the SimulES board game. The paper describes the game, stresses its strong points, provides initial data on its use and discusses its future.

Non-functional requirements (NFRs), such as security and cost, are generally subjective and oftentimes synergistic or conflicting with each other. Properly dealing with such NFRs requires a large body of knowledge – goals to be achieved, problems or obstacles to be avoided, alternative solutions to mitigate the problems, and the best compromising alternative solution to be selected. However, few patterns exist for dealing with these kinds of knowledge of NFRs. In this paper, we present four kinds of NFR patterns for capturing and reusing knowledge of NFRs – objective pattern, problem pattern, alternatives pattern and selection pattern. NFR patterns may be visually represented, and organized by rules of specialization to create more specific patterns, of composition to build larger patterns, and of instantiation to create new patterns using existing patterns as templates. We have applied the NFR pattern approach to the TJX incident, one of the largest credit card theft in history, as a realistic case study.

It is widely known that, for most computer applications, their users and contexts of usage are quite heterogeneous and change in time. A variability analysis approach was developed to bridge the gap between requirements engineering and human-computer interaction can help identify these variations and design flexible, adaptable and adaptive solutions that accommodate them at interaction time, i.e., during system usage. The core assumption of the approach is that an in-depth exploration of how user goals can be formulated into diverse user requests expressed in a linguistic structure using cases, designers will be better equipped to create solutions that cope with variations during user-system interaction. This paper shows how a set of adaptation-related questions and related interactive solutions may help to bridge the problem and solution spaces of flexible, adaptable and adaptive systems.

Transparency has been, for long, a general requirement for democratic societies. According to Leite [6], transparency will be a central issue in producing software. This work assumes that, for providing software transparency, it is necessary that the processes to be supported or automated be transparent as well. As such, using a requirements point of view, it is necessary that organizations implement process transparency to enable transparency in their automation or support. This work is based on Business Process Management concepts, NFR framework and quality management.

Aspects promote a clear separation of concerns so that tangled and scattered concerns are modularized throughout software development. We propose a framework to trace aspects identified during goal-oriented requirements analysis to code and testing. Two types of checks are performed to validate the resulting system in light of stakeholders' crosscutting concerns. One ensures that systems with and without aspects have the same functionality defined by the hard goals. The other checks whether the weaved system with aspects indeed improves system qualities in terms of the degree of softgoal satisfaction. We demonstrate the approach using an open-source e-commerce platform.

Complex goal oriented information models such as i* and the non functional requirements framework bring up the need to model relationships between goals. In particular when dealing with non-functional goals, also known as softgoals, the modeler faces the problem of how to elicit the complex web of intertwined relationships that exist between them. We tackle this problem by using the personal construct theory (PCT), a well known work in cognitive science. We describe the results of applying PCT to the problem of finding relationships between nonfunctional goals. The process is a heuristic one, and our results, so far, are positive

A reverse engineering process aims at reconstructing high-level abstractions from source code. This paper presents a novel reverse engineering methodology for recovering stakeholder goal models from both structured and unstructured legacy code. The methodology consists of the following major steps: 1) Refactoring source code by extracting methods based on comments; 2) Converting the refactored code into an abstract structured program through statechart refactoring and hammock graph construction; 3) Extracting a goal model from the structured program's abstract syntax tree; 4) Identifying nonfunctional requirements and derive soft goals based on the traceability between the code and the goal model. To illustrate this requirements recovery process, we refactor stakeholder goal models from two legacy software code bases: an unstructured Web-based email in PHP (SquirrelMail) and a structured email client system in Java (Columba).

Nonfunctional requirements (NFRs) have been frequently neglected or forgotten in software design. They have been presented as a second or even third class type of requirement, frequently hidden inside notes. We tackle this problem by treating NFRs as first class requirements. We present a process to elicit NFRs, analyze their interdependencies, and trace them to functional conceptual models. We focus our attention on conceptual models expressed using UML (Unified Modeling Language). Extensions to UML are proposed to allow NFRs to be expressed. We show how to integrate NFRs into the class, sequence, and collaboration diagrams. We also show how use cases and scenarios can be adapted to deal with NFRs. This work was used in three case studies and their results suggest that by using our proposal we can improve the quality of the resulting conceptual models.

The "semantic Web" community poses a new nonfunctional requirement for Web applications. In order to secure interoperability and allow autonomous agent interaction, software for the Web will be required to provide machine processable ontologies. We understand that the responsibility, not only for making explicit this requirement, but also to implement the ontology, belongs to requirements engineers. As such, we see the ontology of a Web application as a sub-product of the requirements engineering activity. In this tutorial we survey the basic principles behind ontologies as they are being implemented and used by the semantic Web community today. Those include ontology languages, tools and construction methods. We focus on a process for ontology construction centered on the concept of application languages. This concept is rooted on a representation scheme called the language extended lexicon (LEL). We demonstrate our approach with examples in which we implement machine processable ontologies in the DAML+OIL language. We finalize with a discussion of today's research issues in ontology engineering, including ontology evolution, integration and validation.

Although Non-Functional Requirements (NFRs) have been present in many software development methods, they have been presented as a second or even third class type of requirement, frequently hidden inside notes and therefore, frequently neglected or forgotten. Surprisingly, despite the fact that non-functional requirements arc among the most expensive and difficult to deal with there are still few works that focus on NFRs as first class requirements. Although these Works have brought a contribution on how to represent and deal with NFRs, two aspects remain not sufficiently explored: how to elicit NFRs and how to merge these NFRs with conceptual models. Our work aims at filling this gap, proposing a strategy to elicit NFRs and to integrate them into conceptual models We focus our attention on conceptual models expressed using UML, and therefore, we propose extensions to UML such that NFRs can be expressed. More precisely, we will show how to integrate NFRs to the Class, Sequence and Collaboration Diagrams. We will also show how Use Cases and Scenarios can be adapted to deal with NFRs. This work was validated by three case studies and their results suggest that by using our proposal we can improve the quality of UML models.

Scenario is a description technique which has attracted much attention not only from practitioners but also from researchers. Literature on this topic shows the possibilities that this description technique provides to enhance the understanding of task-related descriptions and the communication among stakeholders. On the other hand, the idea of pattern, as a description of a problem which occurs over and over again in our environment and its solution, has also attracted lots of attention, especially in software design. The paper describes an initial taxonomy of domain-independent-scenario patterns and proposes a preliminary process to use this taxonomy for scenario construction.

No abstract available.

Complex information systems need conceptual models to deal with aspects beyond the usual entity and activity framework. Recent research has pointed out that conceptual models need to deal with goals, in order to model complex situations that happen in the real world. Our work investigated a new strategy that allows the integration of non-functional requirements (NFR) into data models. Integration is done by representing the NFRs in a data model and investigating how NFR's satisfaction affects the data model. We adopted the widely used ER conceptual model as the data modeling representation schema. In order to start the validation of our strategy we applied it to a real system. The results so far confirm our hypothesis that NFR's integration into data models do help in achieving better understanding of what is being modeled.

Good documentation is essential to the production and evolution of quality software. Based on a survey on program documentation, we propose a documentation architecture that aims to fulfil several requirements of an ideal solution. The architecture integrates a powerful transformation system (Draco-PUC) and a versatile CASE tool (Talisman) in order to produce documents using reverse-engineering strategies. We have implemented such an approach in a prototype tool called Documentu, which uses a database to store system-wide information and uses a standard HTML hypertext browser to help the access and navigation of system documentation. The prototype was used on a large scientific system that belongs to an oil company, with positive results. © 1998 John Wiley & Sons, Ltd.

Scenarios are well recognized as an important strategy towards understanding the interface between the environment and the system, as well as a means to elicit and specify software behavior. We have a broader understanding of scenarios: for us, a scenario is an evolving description of situations in the environment. Our proposal is framed by Leite's (1995) work on a client-oriented requirements baseline, which aims at modeling the external requirements of a software system and its evolution. Scenarios start by describing the environmental situation, according to the main actions performed outside the software system. Scenarios also help the clarification of the interrelation between functional and non-functional requirements. We have validated our strategy and related representations based on case studies of a real situation.

Transformation systems have been applied in several areas of software engineering. This paper describes the use of the transformational engine Draco-PUC in porting COBOL programs. We describe the porting strategy for going from COBOL to C/C++ and give examples of such a strategy applied to a radar application and also to a payroll system. Although targeting an object-orientated language, we do not claim to generate code that strictly follows the OO guidelines. This paper gives special attention to the knowledge structure we have been using to help guide the transformation process as well as to help in the process of design recovery. © 1997 by John Wiley & Sons, Ltd. J. Software Maintenance 9: 3–31, 1997

Traceability, a major issue in software engineering, is seldom present at the initial requirements engineering process. The paper reports a proposal for organizing requirements statements as a model, where change and evolution are taken into consideration. The model uses natural language statements as its basic representation, which helps the communication between clients and software engineers. The model is supported by a customized software system for which a prototype was built and used in an industrial setting.

Draco-PUC is a partial implementation of the Draco Paradigm for software development. The Draco paradigm states that it is possible to develop software based on the reuse of high level abstractions which are described as special purpose languages. These languages are called Domain languages. Draco-PUC is a meta program generator that makes it possible the construction and usage of domain languages. In this paper, we review the basic aspects of the Draco paradigm and point out our experience in building and using Draco-PUC. We stress the problems faced with the supporting technologies and provide some reusability data for the User Interface Domain.>

A strategy for conceptual model acquisition is proposed. Knowledge acquisition is performed with a simple structure, i.e., the lexicon. Using the lexicon and an AI-based approach, a conceptual model is derived. The approach assists in the construction of a first cut version of the conceptual model, which should undergo a validation process. A prototype is built using an object-oriented AI shell. The system is tested with a library example (a 50 entries lexicon).>

A specific technique-viewpoint resolution-is proposed as a means of providing early validation of the requirements for a complex system, and some initial empirical evidence of the effectiveness of a semi-automated implementation of the technique is provided. The technique is based on the fact that software requirements can and should be elicited from different viewpoints, and that examination of the differences resulting from them can be used as a way of assisting in the early validation of requirements. A language for expressing views from different viewpoints and a set of analogy heuristics for performing a syntactically oriented analysis of views are proposed. This analysis of views is capable of differentiating between missing information and conflicting information, thus providing support for viewpoint resolution.>