Software Development Artifacts Research Articles

A systematic literature review of pre-requirements specification traceability

Requirements traceability (RT) is the ability to link requirements to other software development artifacts. In pre-requirements (pre-RS) traceability, requirements are linked to their origin, such as interviews with stakeholders, meeting protocols, or legacy systems. Compared with post-RS traceability, which links requirements to source code and other later artifacts, pre-RS traceability has seen much less research. This article presents a systematic literature review of pre-RS traceability based on 77 articles published between 1992 and 2022, aiming to provide a comprehensive overview of its use cases, benefits, problems, and solutions. Through the analysis of existing literature, this review identifies gaps for future research and establishes a foundation for future investigations in the field of pre-RS traceability.

АНАЛИЗ ИСПОЛЬЗОВАНИЯ МОДЕЛЕЙ КОММУНИКАЦИИ В ЖИЗНЕННОМ ЦИКЛЕ РАЗРАБОТКИ ИНФОРМАЦИОННЫХ СИСТЕМ

The article analyzes the existing communication models and their applicability to the tasksof organizing effective communication in the process of developing information systems. The useof communication models in combination with various, most commonly used models of the lifecycle of information systems – waterfall, spiral, SCRUM - is considered. The advantages and disadvantagesof such combinations and their causes are analyzed on the example of T. Newcomb'smodel. The main element of communication is to ensure understanding between the two participantsregarding the object that arises in the project at the next step of its implementation.The systematization of knowledge and information is presented, taking into account the subjectsand forms of its presentation. The analysis shows that the models, realizing the ideas embedded inthem, correspond to different life cycle models to varying degrees, but none of the communicationmodels fully solves communication problems in the development of information systems. The performedstudies show that none of the combinations of models allows to effectively organize communicationbetween participants in the development process. It is necessary to radically revisemodels and mechanisms in such a way that subjects can communicate at the stage of preparingactions to create software development artifacts, and not based on the results of their implementation.Approaches involving the development and use of communication tools – LOW/No code platforms,or other CASE-tools that allow the user and the developer to communicate while preservingthe context of the transmitted knowledge are focused on eliminating such problems. The study ofthe features and structure of such tools will be the subject of further research.

Human values in software development artefacts: A case study on issue discussions in three Android applications

Human values such as inclusion, privacy, and accessibility need to be considered during software development to attract and maintain users. However, little effort has been made to study human values consideration in software development, particularly in software development artefacts.

Integrated Traceability Approach for an Effective Impact Analysis

Change is inevitable, software undergoes continuous change during its life cycle. A small change can trigger high evolution because of the ripple effect identified during the activity of impact analysis. However, it depends on the traceability information, which is the connection between software development artifacts. The current traceability techniques lack the breadth and depth to carryout informative impact analysis. We have performed a detailed literature survey of traceability techniques from the year 2008-2018. These techniques are evaluated on the criteria for effective impact analysis present in the literature. The results highlight that no single technique fulfills the criteria for effective impact analysis alone, they can be combined together to achieve promising results. We have presented a hybrid approach that combines four traceability techniques to achieve the entire criteria for an effective impact analysis after careful evaluation. The techniques combined are: Information Retrieval, Pre-Requirement Specification Traceability, Value based Requirements Traceability Technique and Goal Centric Traceability Technique. Our proposed hybrid approach is empirically validated via a field experiment. Results are analyzed for time and effort utilized in maintaining and retrieving the traceability information. The results are promising as the hybrid approach achieves effective impact analysis within minimal time and effort. We plan to extend the validation to real world impact analysis situation via case study.

Software Defect Prediction for Healthcare Big Data: An Empirical Evaluation of Machine Learning Techniques.

Software defect prediction (SDP) in the initial period of the software development life cycle (SDLC) remains a critical and important assignment. SDP is essentially studied during few last decades as it leads to assure the quality of software systems. The quick forecast of defective or imperfect artifacts in software development may serve the development team to use the existing assets competently and more effectively to provide extraordinary software products in the given or narrow time. Previously, several canvassers have industrialized models for defect prediction utilizing machine learning (ML) and statistical techniques. ML methods are considered as an operative and operational approach to pinpoint the defective modules, in which moving parts through mining concealed patterns amid software metrics (attributes). ML techniques are also utilized by several researchers on healthcare datasets. This study utilizes different ML techniques software defect prediction using seven broadly used datasets. The ML techniques include the multilayer perceptron (MLP), support vector machine (SVM), decision tree (J48), radial basis function (RBF), random forest (RF), hidden Markov model (HMM), credal decision tree (CDT), K-nearest neighbor (KNN), average one dependency estimator (A1DE), and Naïve Bayes (NB). The performance of each technique is evaluated using different measures, for instance, relative absolute error (RAE), mean absolute error (MAE), root mean squared error (RMSE), root relative squared error (RRSE), recall, and accuracy. The inclusive outcome shows the best performance of RF with 88.32% average accuracy and 2.96 rank value, second-best performance is achieved by SVM with 87.99% average accuracy and 3.83 rank values. Moreover, CDT also shows 87.88% average accuracy and 3.62 rank values, placed on the third position. The comprehensive outcomes of research can be utilized as a reference point for new research in the SDP domain, and therefore, any assertion concerning the enhancement in prediction over any new technique or model can be benchmarked and proved.

Domain engineering approach of software requirements analysis

Requirement analysis is one of the important processes in software development lifecycle management. In Agile approach requirements software models are the basic of generating other software development artifacts. Improving requirements approaches and techniques allows avoiding mistakes in other software development artifacts. Domain engineering fundamentals is the basic for “template oriented” approaches of software development artifacts designing. Reusing domain models and knowledge allows adding details in vertical “model to model” transformation operations, refine generated software development artifacts, organize systematic software reuse and perform many other activities. Paper proposes an approach of requirement analysis based on UML Use Case diagrams transformations into communication ones and the next refinements of them by means of information from domain models. The advantages of the proposed approach is the next: proposed transformation method involves ”many to many” transformation in order to save the semantic of initial model. Domain knowledge are used to complete communication diagram by means of adding details after transformation to them. In order to perform Use case to communication transformation graph representation of software models is chosen.

Programmer Experience: A Systematic Mapping

User eXperience (UX) identifies the perceptions of people over of the use (or even the anticipated use) of a product, system or service. The programmers are users of specific systems, and several types of software development artifacts, such as programming environments and design documents. We performed a systematic mapping about Programmer eXperience (PX). In this work we consider the programmers as a particular type of users of particular artifacts. We therefore consider PX as a particular type of UX. The literature usually focuses on PX from a Software Engineering point of view. We analyzed PX mainly from a Human-Computer Interaction (HCI) perspective. We reviewed articles about PX, empirical studies related to aspects of PX, and studies addressing PX on programming environments. The results show that there is an interest on the PX, but the concept is not yet clearly defined. We found 40 articles published in the last ten years and established that the studies address usability and PX aspects focusing on four topics: (i) programming languages, (ii) programmers’ interaction with the integrated development environment, (iii) application programming interfaces, and (iv) articles about programmers’ behavior. It is a relatively small numbers of articles, compared with other Software Engineering or HCI areas. This represents a research opportunity for this systematic review and others that can be performed.

Programmer eXperience: A Systematic Literature Review

Programmers use various software development artifacts in their work, such as programming environments, design documents, and programming codes. These software artifacts can be studied and improved based on usability and User eXperience (UX) factors. In this paper, we consider programmers to be a specific case of users and analyze different elements that influence their experience in this specific context. We conducted a systematic literature review of papers published over the last ten years related to 1) the definition of the Programmer eXperience (PX); 2) the PX, UX, and usability factors regarding the programming environments, design documents, and programming codes; and 3) sets of heuristics to evaluate the software development artifacts mentioned before. We analyzed 73 articles, and the results obtained show that: 1) the important elements that influence the PX are the motivation of programmers and the choice of tools they use in their work, such as programming environments; 2) most of the identified studies (59%) aimed to evaluate the influence of the PX, UX, and usability on programming environments; 3) the majority of the studies (70%) used methods such as usability tests and/or heuristic evaluation methods; and 4) four sets of heuristics are used to evaluate software development artifacts in relation to programming environments, programming languages, and application programming interfaces. The results suggest that further research in this area is necessary to better understand and evaluate the concept of the PX. © 2013 IEEE.

Towards A Knowledge Base for Software Developers to Choose Suitable Traceability Techniques

Huge amount of techniques for creating, maintaining and/or recovering traceability among software development artifacts have been proposed. It is thus not easy for a potential user of such techniques to choose a technique suitable for his/her project because too many techniques exist and projects are different from each other. In this paper, we proposed a model for characterizing a traceability technique with respect to its users. The model can become a meta-model of the knowledge base for such users. The model is designed on the basis of the contents of existing technical papers so that we can easily describe model instances on the basis of technical papers. The model is represented in a feature model, and it has four mandatory features: source, destination, consequence and process. The user can at least understand a technique is unsuitable for him/her by referring such features. If a technique estimates the traceability relationships, the instance of its feature model may contain the quality metrics of its estimation such as precision and recall. It has also several optional features: assumptions, preprocess and tool. Although we sometimes cannot obtain such optional features from technical papers, they are so helpful for a user to decide a technique suitable for him/her. On the basis of the feature model, we described model instances of several techniques in technical papers. We also examined and discussed who the suitable user for each technique is.

Reasoning about UML/OCL class diagrams using constraint logic programming and formula

Model Driven Engineering promotes the use of models as the main artifacts in software and system development. Verification and validation of models are key activities to ensure the quality of the system under development. This paper presents a framework to reason about the satisfiability of class models described using the Unified Modeling Language (UML). The proposed framework allows us to identify possible design flaws as early as possible in the software development cycle. More specifically, we focus on UML Class Diagrams annotated with Object Constraint Language (OCL) invariants, which are considered to be the main artifacts in Object-Oriented analysis and design for representing the static structure of a system. We use the Constraint Logic programming (CLP) paradigm to reason about UML Class Diagrams modeling foundations. In particular, we use Formula as a model-finding and design space exploration tool. We also present an experimental Eclipse plug-in, which implements our UML model to Formula translation proposal following a Model Driven Architecture (MDA) approach. The proposed framework can be used to reason, validate, and verify UML Class Diagram software designs by checking correctness properties and generating model instances using the model exploration tool Formula.

Fitting Security into Agile Software Development

Security objectives in software development are increasingly convergent with the business objectives, as requirements for privacy and the cost of security incidents call for more dependable software products. The development of secure software is accomplished by augmenting the software development process with specific security engineering activities. Security engineering, in contrast to the iterative and incremental software development processes, is characterized by sequential life cycle models: the security objectives are thus to be achieved by conflicting approaches. In this study, to identify the incompatibilities between the approaches, the security engineering activities from Microsoft SDL, the ISO Common Criteria and OWASP SAMM security engineering models are mapped into common agile software development processes, practices and artifacts.

A logical approach to systems engineering artifacts: semantic relationships and dependencies beyond traceability—from requirements to functional and architectural views

Not only system assurance drives a need for semantically richer relationships across various artifacts, work products, and items of information than are implied in the terms "trace and traceability" as used in current standards and textbooks. This paper deals with the task of working out artifacts in software and system development, their representation, and the analysis and documentation of the relationships between their logical contents--herein referred to as tracing and traceability; this is a richer meaning of traceability than in standards like IEEE STD 830. Among others, key tasks in system development are as follows: capturing, analyzing, and documenting system-level requirements, the step to functional system specifications, the step to architectures given by the decomposition of systems into subsystems with their connections and behavioral interactions. Each of these steps produces artifacts for documenting the development, as a basis for a specification and a design rationale, for documentation, for verification, and impact analysis of change requests. Crucial questions are how to represent and formalize the content of these artifacts and how to relate their content to support, in particular, system assurance. When designing multi-functional systems, key artifacts are system-level requirements, functional specifications, and architectures in terms of their subsystem specifications. Links and traces between these artifacts are introduced to relate their contents. Traceability has the goal to relate artifacts. It is required for instance in standards for functional system safety such as the ISO 26262. An approach to specifying semantic relationships is shown, such that the activity of creating and using (navigating through) these relationships can be supported with automation.

Evaluating the Usability of Model Transformations Testing Approach (MTTA)

Model Transformation (MT) is a key component in Model Driven Development (MDD). Model transformation is used to transform source model into a target model, improve the model quality and also introduce the design pattern and refactoring. Model transformation are not free from bugs similar to other software development artifacts and it needs to be verified. Code Generators (CG) are a type of model transformation that automatically generate code from software models. To verify a CG using Model Transformation Testing Approach (MTTA) effectively, MTTA requires the users to manually generate test model and develop assertions. Since both tasks are performed manually, a usability study is conducted to gauge the effects of the manual tasks towards the usability of MTTA from three perspective: Learnability, effectiveness and efficiency. The aim of this paper is to identify the usability problems of MTTA related to its learnability, efficiency and effectiveness. Usability test technique is used in this study and questionnaire was used to collect a quantitative data from the participants. A pilot test was conducted with two participants and later eight participants were recruited for the real test. The result shows that MTTA is learnable and effective but inefficient. We conclude with a discussion on the reason why MTTA is inefficient.

Test Framework Requirements to Verify Artifacts in Software R&D Project

Researchers do not effectively manage and verify artifacts produced during software R&D projects. And testing software development artifacts cannot test the whole software R&D project. It is necessary to perform continuous and detailed verification of artifacts produced in each phase during software R&D project. Thus, a framework is required to test software and verify documents generated during software R&D project. In this paper, we present requirements of test framework to verify software R&D projects. The requirements are represented with scenarios and use cases for the framework. We show effectiveness of our approach by presenting a part of prototype in case study.

Tracking Developers' Eyes in the IDE

With recorded eye gaze sessions, researchers will be able to determine all the locations that developers examine in software development artifacts. This will pave the way to further improve IDEs to support developers in various software engineering tasks. Toward that goal, researchers developed iTrace, software that interfaces with an eye tracker and IDE to capture eye gaze on software artifacts and map them to their semantic meaning.

An Integrated Software Testing Framework for FPGA-Based Controllers in Nuclear Power Plants

Field-programmable gate arrays (FPGAs) have received much attention from the nuclear industry as an alternative platform to programmable logic controllers for digital instrumentation and control. The software aspect of FPGA development consists of several steps of synthesis and refinement, and also requires verification activities, such as simulations that are performed individually at each step. This study proposed an integrated softwaretesting framework for simulating all artifacts of the FPGA software development simultaneously and evaluating whether all artifacts work correctly using common oracle programs. This method also generates a massive number of meaningful simulation scenarios that reflect reactor shutdown logics. The experiment, which was performed on two FPGA software implementations, showed that it can dramatically save both time and costs.

A New Generalization of the Additive Weibull Distribution: Theory and Applications

The unified modeling language (UML) is widely used to analyze and design different software development artifacts in an object oriented development. Domain model is a significant artifact that models the problem domain and visually represents real world objects and relationships among them. It facilitates the comprehension process by identifying the vocabulary and key concepts of the business world. Category list technique identifies concepts and associations with the help of pre defined categories, which are important to business information systems. Whereas noun phrasing technique performs grammatical analysis of use case description to recognize concepts and associations. Both of these techniques are used for the construction of domain model, however, no empirical evidence exists that evaluates the quality of the resultant domain model constructed via these two basic techniques. A controlled experiment was performed to investigate the impact of category list and noun phrasing technique on quality of the domain model. The constructed domain model is evaluated for completeness, correctness and effort required for its design. The obtained results show that category list technique is better than noun phrasing technique for the identification of concepts as it avoids generating unnecessary elements i.e. extra concepts, associations and attributes in the domain model. The noun phrasing technique produces a comprehensive domain model and requires less effort as compared to category list. There is no statistically significant difference between both techniques in case of correctness.

Impact of Domain Modeling Techniques on the Quality of Domain Model: An Experiment

The unified modeling language (UML) is widely used to analyze and design different software development artifacts in an object oriented development. Domain model is a significant artifact that models the problem domain and visually represents real world objects and relationships among them. It facilitates the comprehension process by identifying the vocabulary and key concepts of the business world. Category list technique identifies concepts and associations with the help of pre defined categories, which are important to business information systems. Whereas noun phrasing technique performs grammatical analysis of use case description to recognize concepts and associations. Both of these techniques are used for the construction of domain model, however, no empirical evidence exists that evaluates the quality of the resultant domain model constructed via these two basic techniques. A controlled experiment was performed to investigate the impact of category list and noun phrasing technique on quality of the domain model. The constructed domain model is evaluated for completeness, correctness and effort required for its design. The obtained results show that category list technique is better than noun phrasing technique for the identification of concepts as it avoids generating unnecessary elements i.e. extra concepts, associations and attributes in the domain model. The noun phrasing technique produces a comprehensive domain model and requires less effort as compared to category list. There is no statistically significant difference between both techniques in case of correctness.

Boa

In today's software-centric world, ultra-large-scale software repositories, such as SourceForge, GitHub, and Google Code, are the new library of Alexandria. They contain an enormous corpus of software and related information. Scientists and engineers alike are interested in analyzing this wealth of information. However, systematic extraction and analysis of relevant data from these repositories for testing hypotheses is hard, and best left for mining software repository (MSR) experts! Specifically, mining source code yields significant insights into software development artifacts and processes. Unfortunately, mining source code at a large scale remains a difficult task. Previous approaches had to either limit the scope of the projects studied, limit the scope of the mining task to be more coarse grained, or sacrifice studying the history of the code. In this article we address mining source code: (a) at a very large scale; (b) at a fine-grained level of detail; and (c) with full history information. To address these challenges, we present domain-specific language features for source-code mining in our language and infrastructure called Boa . The goal of Boa is to ease testing MSR-related hypotheses. Our evaluation demonstrates that Boa substantially reduces programming efforts, thus lowering the barrier to entry. We also show drastic improvements in scalability.

Exploiting traceability uncertainty among artifacts and code

Traceability between software development artifacts and code has proven to save effort and improve quality. However, documenting and maintaining such traces remains highly unreliable. Traceability is rarely captured immediately while artifacts and code co-evolve. Instead they are recovered later. By then key people may have moved on or their recollection of facts may be incomplete and inconsistent. This paper proposes a language for capturing traceability that allows software engineers to express arbitrary assumption about the traceability between artifacts and code – even assumptions that may be inconsistent or incomplete. Our approach takes these assumptions to reasons about their logical consequences (hence increasing completeness) and to reveal inconsistencies (hence increasing correctness). In doing so, our approach’s reasoning is correct even in the presence of known inconsistencies. This paper demonstrates the correctness and scalability of our approach on several, large-scale third-party software systems. Our approach is automated and tool supported.