Search

Machine Learning (ML) algorithms are widely used in building software-intensive systems, including safety-critical ones. Unlike traditional software components, Machine-Learned Components (MLC)s, software components built using ML algorithms, learn their specifications through generalizing the common features that they find in a limited set of collected examples. While this inductive nature overcomes the limitations of programming hard-to-specify concepts, the same feature becomes problematic for verifying safety in ML-based software systems. One reason is that, due to MLCs data-driven nature, there is often no set of explicitly written and pre-defined specifications, against which the MLC can be verified. In this regard, we propose to partially specify hard-to-specify domain concepts, which MLCs tend to classify, instead of fully relying on their inductive learning ability from arbitrarily-collected datasets. In this paper, we propose a semi-automated approach to construct a multi-level semantic web to partially outline the hard-to-specify, yet crucial, domain concept "pedestrian" in automotive domain. We evaluate the applicability of the generated semantic web in two ways: first, with a reference to the web, we augment a pedestrian dataset for a missing feature, wheelchair, to show training a state-of-the-art ML-based object detector on the augmented dataset improves its accuracy in detecting pedestrians; second, we evaluate the coverage of the generated semantic web based on multiple state-of-the-art pedestrian and human datasets. [ABSTRACT FROM AUTHOR]

In software reuse, the reuse of UML class diagram produced in design phase has received more attention due to the important influence on the following developing process. The reuse is based on similarity. The similarity between class diagrams contains semantic and structural aspects. The existing works focus on semantic similarity, while the structural similarity is little paid attention to. The structure of class diagram can be categorized into two aspects: intra-structure and inter-structure. The intra-structure refers to the composition of each class, and the inter-structure is represented as the relationships between classes. So, the structural similarity measure should be carried out from these two aspects. In this paper, we propose to use a graph named UML class graph (UCG) to represent a class diagram for the structural similarity measure. An algorithm based on UCG Maximum Common Subgraph Sequence is proposed for the inter-structure similarity measure, and UCG edit distance is proposed and introduced to the intra-structure similarity measure. The experimental results show that our proposed approach is effective within a domain or across domains. [ABSTRACT FROM AUTHOR]

In this paper, we describe a novel unsupervised approach for detecting, classifying, and tracing non-functional software requirements (NFRs). The proposed approach exploits the textual semantics of software functional requirements (FRs) to infer potential quality constraints enforced in the system. In particular, we conduct a systematic analysis of a series of word similarity methods and clustering techniques to generate semantically cohesive clusters of FR words. These clusters are classified into various categories of NFRs based on their semantic similarity to basic NFR labels. Discovered NFRs are then traced to their implementation in the solution space based on their textual semantic similarity to source code artifacts. Three software systems are used to conduct the experimental analysis in this paper. The results show that methods that exploit massive sources of textual human knowledge are more accurate in capturing and modeling the notion of similarity between FR words in a software system. Results also show that hierarchical clustering algorithms are more capable of generating thematic word clusters than partitioning clustering techniques. In terms of performance, our analysis indicates that the proposed approach can discover, classify, and trace NFRs with accuracy levels that can be adequate for practical applications. [ABSTRACT FROM AUTHOR]

Software requirements are often not set in concrete at the start of a software development project; and requirement changes become necessary and sometimes inevitable due to changes in customer requirements and changes in business rules and operating environment; hence, requirements development, which includes requirements changes, is a part of a software process. Previous research reports that correcting requirements errors late costs many times more than correcting them during the requirements development phase. There is, hence, a need to manage them well and to analyse them in order to identify the impacts, difficulties and potential conflicts with existing requirements. Most studies on requirements change analysis are done at the source code level while paying less attention to the initiation of changes at a higher level. In this paper, we present a method of requirements change analysis based on the changes themselves which are initiated at higher levels. This method consists of three steps: namely (1) analysing the change using functions, (2) identifying the change difficulty and (3) identifying the dependencies using a matrix. We illustrate the usefulness of our method by applying it to a course management system of a university. [ABSTRACT FROM AUTHOR]

Rationale refers to the reasoning and justification behind human decisions, opinions, and beliefs. In software engineering, rationale management focuses on capturing design and requirements decisions and on organizing and reusing project knowledge. This paper takes a different view on rationale written by users in online reviews. We studied 32,414 reviews for 52 software applications in the Amazon Store. Through a grounded theory approach and peer content analysis, we investigated how users argue and justify their decisions, e.g., about upgrading, installing, or switching software applications. We also studied the occurrence frequency of rationale concepts such as issues encountered or alternatives considered in the reviews and found that assessment criteria like performance, compatibility, and usability represent the most pervasive concept. We identified a moderate positive correlation between issues and criteria and furthermore assessed the distribution of rationale concepts with respect to rating and verbosity. We found that issues tend to appear more in lower star rated reviews, while criteria, alternatives, and justifications seem to appear more in three star rated reviews. Also, reviews reporting alternatives seem to be more verbose than reviews reporting criteria. A follow-up qualitative study of sub-concepts revealed, that users also report other alternatives (e.g., alternative software provider), criteria (e.g., cost), and decisions (e.g., on rating software). We then used the truth set of manually labeled review sentences to explore how accurately we can mine rationale concepts from the reviews. We evaluated the classification algorithms Naive Bayes, Support Vector Machine, Logistic Regression, Decision Tree, Gaussian Process, Random Forest, and Multilayer Perceptron Classifier using a baseline and random configuration. Support Vector Classifier, Naive Bayes, and Logistic Regression, trained on the review metadata, syntax tree of the review text, and influential terms, achieved a precision around 80% for predicting sentences with alternatives and decisions, with top recall values of 98%. On the review level, precision was up to 13% higher with recall values reaching 99%. Using only word features, we achieved in most cases the highest precision and highest recall respectively using the Random Forest and Naive Bayes algorithm. We discuss the findings and the rationale importance for supporting deliberation in user communities and synthesizing the reviews for developers. [ABSTRACT FROM AUTHOR]

Requirements engineering (RE) has attracted a great deal of attention from researchers and practitioners in recent years. Requirements engineering education (REE) is therefore an important undertaking if the field is to have professionals who are capable of successfully accomplishing software projects. This increasing interest demands that academia should provide software engineering students with a solid foundation in the subject matter. This paper aims to identify and to present the current research on REE that is available at present, and to select useful approaches and needs for future research. A systematic mapping study was therefore performed to classify the selected studies into five classification criteria: research type, empirical type, contribution type, RE activity, and curricula. A total of 79 papers were selected and classified according to these criteria. The results of this systematic mapping study are discussed, and a list of advice obtained from the REE literature for instructors is provided. [ABSTRACT FROM AUTHOR]

Software reuse can be defined as the process of creating software products from the existing ones rather than developing software from scratch. Thus, software reuse is normally proposed to increase software productivity and quality and leads to economic benefits. In this sense, the reuse of software requirements has received important attention because it provides a solid support to develop quality software through obtaining and reusing quality software requirements [i.e., software product line (SPL) approach used in large-sized software enterprises]. However, the small-sized enterprises-which represent up to 85 % of all software organizations in many countries around the world-cannot implement a SPL approach because it does not fit with the context, properties, and complexity of their software projects. Moreover, the software engineering community has not adequately explored a more proper approach in the context of small-sized software enterprises. The use of a software requirements catalog could be this proper approach. In this context, the aim of this paper was to introduce the requirements reuse model for software requirements catalog (RRMSRC). Also, a set of guidelines to perform the main activities defined for reusing functional requirements within small-sized software enterprises is provided. As evidence of its feasibility, RRMSRC has been used in an industrial context, and the obtained results and learned lessons are summarized. [ABSTRACT FROM AUTHOR]

Global software development (GSD), where software teams are located in different parts of the world, has become increasingly popular. To devise a high-quality software requirements specification (SRS), effective communication and collaboration between stakeholders are necessary for GSD. However, geographical distance, cultural diversity, differences in time zones and language barriers create difficulties for stakeholders in engaging in effective collaboration. Taking into consideration the factors involved in GSD, previous research showed that the ways by which requirements are documented and validated for collocated software development projects cannot be used effectively for GSD. In this paper, we present a method of GSD requirements specification and validation. Our method begins with generating a requirements graph to understand details of the software requirements with respect to different GSD sites. The information obtained from a requirements graph is to be contained in a requirements specification document, and then be circulated between different GSD sites for reviewing, updating and finalizing its content. Finally, the requirements contained in the specification document are to be validated by generating and comparing validation matrices at different GSD sites. Past researchers used student groups in a university environment to play the roles of stakeholders in experiments in GSD studies. We therefore validate our method by applying it to a case study of an online shopping system, where the roles of stakeholders were played by a group of students. [ABSTRACT FROM AUTHOR]

This paper proposes an explicit definition of green software requirements and a tool to support their evaluation . The proposed evaluation tool describes the green efficiency by considering the energy consumption as the main aspect to be studied during the development stage. This approach consists of building a multiple regression model, by using a supervised learning algorithm, in order to reproduce the energy consumption pattern of devices at different workload circumstances. The energy consumption model is then deployed to estimate the impact of software applications based on their resource usage. Our work has been validated on desktop and mobile devices. The experiments show the effectiveness of the proposed energy profiling tool that provided relevant information on the energy consumption of software applications. [ABSTRACT FROM AUTHOR]

Large-scale software applications are complex systems that involve a myriad of different concerns. Ideally, these concerns should be organized into separated and different modules, but often some of these concerns overlap and crosscut each other. Such a situation is problematic, as concerns are tangled and scattered into different modules; thus, design and source code become difficult to produce and maintain. The Modularity community has been addressing crosscutting concerns by developing techniques based on separation of concerns. This separation must be done as early as possible during software construction to obtain a more modular and consequently better maintainable software, where evolution is performed with less effort and the possibility of introducing unforeseen mistakes is minimal. In this paper, we propose a strategy to identify crosscutting concerns at requirements level, i.e., at early stages in the software development process, by using the Language Extended Lexicon. [ABSTRACT FROM AUTHOR]

There is a general consensus on the importance of good requirements engineering for achieving high-quality software. Functional requirements capture the intended behavior of the system in terms of services, tasks, or functions the system is required to perform, while non-functional requirements capture required properties of the system, such as timing, performance, and security. These non-functional requirements play a crucial role during system development life cycle serving as selection criteria for choosing among myriads of design decisions. The ability to model and validate the system non-functional properties at the requirements level supports the detection of design errors during the early stages of a software development life cycle and helps reduce the cost of later redesign activities. The widespread interest in time modeling and analysis techniques at the requirements phase provides the major motivation for this research. This paper presents a novel and fully automated approach to describe and validate high-level timed requirements using the Timed Use Case Maps language. We extend the, ITU-T standard User Requirements Notation, Use Case Maps metamodel with time requirements. The resulting extensions are implemented within the jUCMNav tool and formalized using Abstract State Machines allowing for automated simulation and analysis. We illustrate the applicability of our approach using a business process model (conference review process model) and a real-time system model (IP multicast routing case study). [ABSTRACT FROM AUTHOR]

A correction to this paper has been published: https://doi.org/10.1007/s00766-021-00354-4 [ABSTRACT FROM AUTHOR]