Large-scale Software Projects Research Articles

Improving requirements elicitation in large-scale software projects with reduced customer engagement: a proposed cost-effective model

Improving requirements elicitation in large-scale software projects with reduced customer engagement: a proposed cost-effective model

Identification of Key Classes in Software Systems Based on Static Analysis and Voting Mechanism

Identifying key classes of a software system can help developers understand the system quickly, reduce the time for system maintenance, and prevent security risks caused by defects in key classes. So far, many approaches have been proposed to identify key classes from software systems. However, some approaches select too many key class candidates, making it inconvenient and difficult for developers to start understanding the system from these classes. For the other approaches, although the number of key class candidates is not large, their effectiveness needs to be further improved. To this end, in this paper, we propose a new model, named SAVM, to detect key classes by combining static analysis and a voting mechanism. First, we extract structural information from the source codes of a software system and construct a class coupling network (CCN) using this information. Then, we present the VRWD method that iteratively identifies important nodes in CCN based on a voting mechanism. Specifically, in each iteration, a node votes for its outgoing neighbors and in the meantime receives votes from its incoming neighbors. Afterward, the node that attains the highest voting score is elected as the important node in this turn. Finally, the corresponding classes of the selected important nodes are the key class candidates. The effectiveness of the proposed model and eight other baselines is evaluated in eight open-source Java projects. The experimental results show that although no method performs the best in all projects, according to the average ranking of the Friedman test, our method overall performs better compared to the baselines. In addition, this paper also proves through experiments that our approach can be applied to large-scale software projects. These indicate that our approach is a valuable technique for developers.

Mindfulness and Emotional Intelligence: A Study on Millennials on Hospitality

In software development, dependability and quality are critical. A Bug Tracking System (BTS) designed specifically for large-scale software projects is introduced in this significant project with the goal of streamlining bug tracking, reporting, detection, and resolution. The system provides secure authentication, a backend database that is reliable, and an easy-to-use web interface. Using cutting-edge web technologies, it offers critical features including automated notifications, progress tracking, severity assignment, and thorough bug reporting together with user-friendly interfaces for a range of user roles. Tools for data visualization help identify defect patterns and monitor projects. The project follows best practices recommended by the industry for requirements analysis, design, implementation, testing, and deployment, and it solicits ongoing input. The result is a thorough BTS that addresses defect management difficulties. Thorough testing and assessment in comparison to standards confirms its efficacy. This approach could have a big impact on software development, improving user satisfaction and quality. Furthermore, issues with bug tracking are covered, including distributed team communication, scalability, and automation balancing. Proposals for strategies to address these issues are grounded in scholarly research and professional opinions. This summary highlights the critical role that bug tracking systems play in contemporary software development, making it an invaluable tool for researchers, practitioners, and teams looking to improve bug tracking procedures and raise the caliber and effectiveness of the software development lifecycle. Keywords— Bug Tracking System, Software Development, Defect Management, Quality Assurance, Automation, Collaboration, Large-scale Projects.

Dynamic Race Detection with O(1) Samples

Happens before-based dynamic analysis is the go-to technique for detecting data races in large scale software projects due to the absence of false positive reports. However, such analyses are expensive since they employ expensive vector clock updates at each event, rendering them usable only for in-house testing. In this paper, we present a sampling-based, randomized race detector that processes only constantly many events of the input trace even in the worst case. This is the first sub-linear time (i.e., running in o ( n ) time where n is the length of the trace) dynamic race detection algorithm; previous sampling based approaches like run in linear time (i.e., O ( n )). Our algorithm is a property tester for -race detection — it is sound in that it never reports any false positive, and on traces that are far, with respect to hamming distance, from any race-free trace, the algorithm detects an -race with high probability. Our experimental evaluation of the algorithm and its comparison with state-of-the-art deterministic and sampling based race detectors shows that the algorithm does indeed have significantly low running time, and detects races quite often.

استخدام المنهجيات الحديثة لتطوير النظم في إدارة المعرفة والمعلوماتية الصحية

The importance of developing health care software emerged as a necessary process to transform the paper health care system into a computer-based information system to ensure the effectiveness, efficiency, and quality of health service provision, reduce medical errors and ensure patient safety. The importance of developing health care software also emerged due to the high degree of complexity of health care services, and the accuracy required to ensure that there are no errors. Healthcare software needs to comply with laws and regulations during its development, be more secure and stable than other software, and be high-performance without crashes. In reality, this is often not the common case, as you are going to release a poor-quality product and constantly improve it - you want your product to be trusted and used from day one. Agile software development is an iterative process that creates a usable software product from the early stages, enabling rapid, high-quality development that will respond quickly to changing requirements. The Waterfall model may be a good software development model in the case of large-scale software projects. However, there are many tradeoffs between the two software development approaches, Agile or Waterfall. This paper covers common software development methodologies and discusses the benefits and drawbacks of each of them, and how we can modify them according to the requirements of healthcare information systems. During this research, a hybrid software development methodology (Hybrid Scrum-Fall Model) was proposed to develop the health care system. The proposed model combines the agile Scrum development methodology with the Waterfall model to deliver quality software solutions that deliver greater value to the end user.

Dynamic Mixture of Experts Models for Online Prediction

A mixture of experts models the conditional density of a response variable using a mixture of regression models with covariate-dependent mixture weights. We extend the finite mixture of experts model by allowing the parameters in both the mixture components and the weights to evolve in time by following random walk processes. Inference for time-varying parameters in richly parameterized mixture of experts models is challenging. We propose a sequential Monte Carlo algorithm for online inference based on a tailored proposal distribution built on ideas from linear Bayes methods and the EM algorithm. The method gives a unified treatment for mixtures with time-varying parameters, including the special case of static parameters. We assess the properties of the method on simulated data and on industrial data where the aim is to predict software faults in a continuously upgraded large-scale software project.

BugPre: an intelligent software version-to-version bug prediction system using graph convolutional neural networks

Since defects in software may cause product fault and financial loss, it is essential to conduct software defect prediction (SDP) to identify the potentially defective modules, especially in the early stage of the software development lifecycle. Recently, cross-version defect prediction (CVDP) began to draw increasing research interests, employing the labeled defect data of the prior version within the same project to predict defects in the current version. As software development is a dynamic process, the data distribution (such as defects) during version change may get changed. Recent studies utilize machine learning (ML) techniques to detect software defects. However, due to the close dependencies between the updated and unchanged code, prior ML-based methods fail to model the long and deep dependencies, causing a high false positive. Furthermore, traditional defect detection is performed on the entire project, and the detection efficiency is relatively low, especially on large-scale software projects. To this end, we propose BugPre, a CVDP approach to address these two issues. BugPre is a novel framework that only conducts efficient defect prediction on changed modules in the current version. BugPre utilizes variable propagation tree-based associated analysis method to obtain the changed modules in the current version. Besides, BugPre constructs graph leveraging code context dependences and uses a graph convolutional neural network to learn representative characteristics of code, thereby improving defect prediction capability when version changes occur. Through extensive experiments on open-source Apache projects, the experimental results indicate that our BugPre outperforms three state-of-the-art defect detection approaches, and the F1-score has increased by higher than 16%.

Teknik Elisitasi Kebutuhan Perangkat Lunak: Literatur Review

The selection of software requirements elicitation techniques is very important for organizations as the first step in the software development process. This study is motivated by the existence of problems, where the organization does not understand the type of software being developed, so it is difficult to determine the right need elicitation technique. In this study, a literature review was used by collecting existing studies. Used 17 studies related to the discussion of elicitation techniques used. This study aims to review previous studies so as to produce recommendations for software requirements elicitation techniques. Based on the study, it can be concluded that interview, prototyping and JAD are most often used in software projects. In addition, for the small-medium scale software projects, more use of interviews, JAD, and ERD-based specifications. Meanwhile, the large-scale software projects involve more stakeholders with elicitation techniques such as group discussions, interviews, and parallel discussions to find joint solutions.

PUGH Decision Trapezoidal Fuzzy and Gradient Reinforce Deep Learning for Large Scale Requirement Prioritization

Objective: To prioritize requirements for large scale software projects within time involving uncertainty in the opinions among different stakeholders. Methods: We propose Pugh Trapezoidal Fuzzy and Gradient Reinforce Learning (PTF-GRL) methods for large scale software requirement prioritization. A Pugh Decision-based Trapezoidal Fuzzy Requirement Selection model is designed, inputting the functional and non-functional requirements of the corresponding stakeholders. With the assistance of Trapezoidal Fuzzy Inference, the qualitative factors are mapped with the corresponding numeric factors, which increases the computational efficiency. Findings: Performance is analyzed based on four parameters: The first parameter is accuracy and our method showed improvement of 4%, 7% and 3% compared to JRD-SCRUM, IFS and SRPTackle respectively. The second parameter is prioritization time and found that our method had reduced time of 30%, 37% and 39% compared with existing methods. The third parameter is precision and it was found that our method improves precision by 6%, 10% and 5% compared with the other two methods. The final parameter we consider is the test suite execution and our method showed improvement of 12%, 19% and 5% compared with the existing two methods. Novelty/Applications: The originality of this work indicates the better performance along with the optimal test suite execution even considering the uncertainty factor in the proposed method compared with existing similar methods. Keywords: Software Project; Pugh Decision Matrix; Trapezoidal Fuzzy Inference; Gradient Orientation; Reinforce Learning; Requirement Prioritization

Detecting Resource Release Bugs with Analogical Reasoning

The resource release bugs are a common type of serious programming bug. However, it is hard to catch them by using static detection for the lacking of comprehensive prior knowledge about the release functions. In this paper, a resource release bug detection method is proposed by introducing analogical reasoning on word vectors. First, the functions of the target source code are encoded into word vectors by the word embedding technique in natural language processing. Second, a two-stage reasoning method is developed for automatically identifying unknown resource release functions according to a few well-known seed functions. 3CosAvg algorithm is employed for the first stage, and a new algorithm is designed for the latter, called 3CosAddExchange. Finally, the identified release functions are translated into static analysis rules to detect potential bugs. The experiment shows that the proposed method is effective and efficient for the large-scale software project. Five unknown resource release bugs are successfully detected in the Linux kernel and confirmed by kernel developers.

A spatial–temporal graph neural network framework for automated software bug triaging

The bug triaging process, an essential process of assigning bug reports to the most appropriate developers, is related closely to the quality and costs of software development. Since manual bug assignment is a labor-intensive task, especially for large-scale software projects, many machine learning-based approaches have been proposed to triage bug reports automatically. Although developer collaboration networks (DCNs) are dynamic and evolving in the real world, most automated bug triaging approaches focus on static tossing graphs at a single time slice. Also, none of the previous studies consider periodic interactions among developers. To address the problems mentioned above, in this article, we propose a novel spatial–temporal dynamic graph neural network (ST-DGNN) framework, including a joint random walk (JRWalk) mechanism and a graph recurrent convolutional neural network (GRCNN) model. In particular, JRWalk aims to sample topological structures in a developer collaboration network with two sampling strategies by considering both developer reputation and interaction preference. GRCNN has three components with the same structure, i.e., hourly-periodic, daily-periodic, and weekly-periodic components, to learn the spatial–temporal features of nodes on dynamic DCNs. We evaluated our approach’s effectiveness by comparing it with several state-of-the-art graph representation learning methods in three domain-specific tasks (i.e., the bug fixer prediction task and two downstream tasks of graph representation learning: node classification and link prediction). In the three tasks, experiments on two real-world, large-scale developer collaboration networks collected from the Eclipse and Mozilla projects indicate that the proposed approach outperforms all the baseline methods on three different time scales (i.e., long-term, medium-term, and short-term predictions) in terms of F1−score.

Origins and Consequences of Misunderstood/Slipped Requirements on Large Scale Software Projects

Origins and Consequences of Misunderstood/Slipped Requirements on Large Scale Software Projects

Architecture Anti-Patterns: Automatically Detectable Violations of Design Principles

In large-scale software systems, error-prone or change-prone files rarely stand alone. They are typically architecturally connected and their connections usually exhibit architecture problems causing the propagation of error-proneness or change-proneness. In this paper, we propose and empirically validate a suite of architecture anti-patterns that occur in all large-scale software systems and are involved in high maintenance costs. We define these architecture anti-patterns based on fundamental design principles and Baldwin and Clark's design rule theory. We can automatically detect these anti-patterns by analyzing a project's structural relationships and revision history. Through our analyses of 19 large-scale software projects, we demonstrate that these architecture anti-patterns have significant impact on files' bug-proneness and change-proneness. In particular, we show that 1) files involved in these architecture anti-patterns are more error-prone and change-prone; 2) the more anti-patterns a file is involved in, the more error-prone and change-prone it is; and 3) while all of our defined architecture anti-patterns contribute to file's error-proneness and change-proneness, Unstable Interface and Crossing contribute the most by far.

Adapting Behavior Driven Development (BDD) for large-scale software systems

Context:Large-scale software projects require interaction between many stakeholders. Behavior-driven development (BDD) facilitates collaboration between stakeholders, and an adapted BDD process can help improve cooperation in a large-scale project. Objective:The objective of this study is to propose and empirically evaluate a BDD based process adapted for large-scale projects. Method:A technology transfer model was used to propose a BDD based process for large-scale projects. We conducted six workshop sessions to understand the challenges and benefits of BDD. Later, an industrial evaluation was performed for the process with the help of practitioners. Results:From our investigations, understanding of a business aspect of requirements, their improved quality, a guide to system-level use-cases, reuse of artifacts, and help for test organization are found as benefits of BDD. Practitioners identified the following challenges: specification and ownership of behaviors, adoption of new tools, the software projects’ scale, and versioning of behaviors. We proposed a process to address these challenges and evaluated the process with the help of practitioners. Conclusion:The evaluation proved that BDD could be adapted and used to facilitate interaction in large-scale software projects in the software industry. The feedback from the practitioners helped in improving the proposed process.

Resource Optimization-Based Software Risk Reduction Model for Large-Scale Application Development

Software risks are a common phenomenon in the software development lifecycle, and risks emerge into larger problems if they are not dealt with on time. Software risk management is a strategy that focuses on the identification, management, and mitigation of the risk factors in the software development lifecycle. The management itself depends on the nature, size, and skill of the project under consideration. This paper proposes a model that deals with identifying and dealing with the risk factors by introducing different observatory and participatory project factors. It is assumed that most of the risk factors can be dealt with by doing effective business processing that in response deals with the orientation of risks and elimination or reduction of those risk factors that emerge over time. The model proposes different combinations of resource allocation that can help us conclude a software project with an extended amount of acceptability. This paper presents a Risk Reduction Model, which effectively handles the application development risks. The model can synchronize its working with medium to large-scale software projects. The reduction in software failures positively affects the software development environment, and the software failures shall reduce consequently.

Deep mining of open source software bug repositories

Large scale software projects adopt bug tracking systems such as Bugzilla and Jira to manage the bugs’ fixes and store their information. Mining bug repositories is essential to automate some maintenance phase activities like bug triage. Recently, embedding and deep learning models have emerged as a breakthrough for text classification applications. This paper proposes utilizing word embedding and deep learning models for mining bug repositories, in order to identify severity classes of newly reported bugs. Embedding models were utilized to represent bug reports, due to their ability to acquire semantic relations among words and sentences. Five effective deep learning models (CNN, LSTM, GRU, hybrid CNN-LSTM/GRU) were trained to classify the bug reports to their severity classes. We attempted these models as each of them has different capabilities; CNN can extract key features of an input and reduce the feature space size. While, LSTM and GRU can represent sequential words (sentences) effectively. Experimental results on two open large-scale bug repositories, Eclipse and Mozilla, demonstrated that CNN model is the superior. However, it was found that the micro-average classification performance of the CNN could be achieved by some traditional classifiers, e.g. SVM and KNN, trained using the embedding vectors instead of the bag-of-words-model.

UCDiff: Difference Detection in Use Case Models of Healthcare System

Development of large-scale healthcare software projects essentially need the efficient management of the created software artifacts during software development process. In such projects different versions of an artifact are created at different times. Traditional software configuration management systems, such as Git, Subversion (SVN), etc., are designed for later phases of software development, which mainly handle the source code document. These systems are unable to perform difference detection and version management tasks on models such as unified modeling language diagrams. UML use case model is used for capturing functional requirements at analyses phase. Different versions of the use case model are created during analyses phase. This paper addresses the detection of differences between two versions of a use case model. In order to perform difference detection, we need to perform three main tasks, i. e., extract the contents of the model, comparison of models and difference representation. Most of the existing approaches in literature of model comparison deal with UML class diagrams. To the best of our knowledge, so far no appropriate approach addresses difference computation of use case model. Existing approaches are not applicable on use case model due to different semantics of use case model. In this research, the concept of model-based software configuration management (SCM) for use case difference detection is proposed. The use case models are created in an open source tool, starUML. The proposed difference algorithm is applied on intermediate tree structure representation of models. As a case study, different versions of a patient appointment healthcare system is used to evaluate different evaluation parameters, such as accuracy, domain independence, high conceptual level and tool independence.

UCDiff: Difference Detection in Use Case Models of Healthcare System

Development of large-scale healthcare software projects essentially need the efficient management of the created software artifacts during software development process. In such projects different versions of an artifact are created at different times. Traditional software configuration management systems, such as Git, Subversion (SVN), etc., are designed for later phases of software development, which mainly handle the source code document. These systems are unable to perform difference detection and version management tasks on models such as unified modeling language diagrams. UML use case model is used for capturing functional requirements at analyses phase. Different versions of the use case model are created during analyses phase. This paper addresses the detection of differences between two versions of a use case model. In order to perform difference detection, we need to perform three main tasks, i. e., extract the contents of the model, comparison of models and difference representation. Most of the existing approaches in literature of model comparison deal with UML class diagrams. To the best of our knowledge, so far no appropriate approach addresses difference computation of use case model. Existing approaches are not applicable on use case model due to different semantics of use case model. In this research, the concept of model-based software configuration management (SCM) for use case difference detection is proposed. The use case models are created in an open source tool, starUML. The proposed difference algorithm is applied on intermediate tree structure representation of models. As a case study, different versions of a patient appointment healthcare system is used to evaluate different evaluation parameters, such as accuracy, domain independence, high conceptual level and tool independence.

Bug severity prediction using question-and-answer pairs from Stack Overflow

Nowadays, bugs have been common in most software systems. For large-scale software projects, developers usually conduct software maintenance tasks by utilizing software artifacts (e.g., bug reports). The severity of bug reports describes the impact of the bugs and determines how quickly it needs to be fixed. Bug triagers often pay close attention to some features such as severity to determine the importance of bug reports and assign them to the correct developers. However, a large number of bug reports submitted every day increase the workload of developers who have to spend more time on fixing bugs. In this paper, we collect question-and-answer pairs from Stack Overflow and use logical regression to predict the severity of bug reports. In detail, we extract all the posts related to bug repositories from Stack Overflow and combine them with bug reports to obtain enhanced versions of bug reports. We achieve severity prediction on three popular open source projects (e,g., Mozilla, Ecplise, and GCC) with Naïve Bayesian, k-Nearest Neighbor algorithm (KNN), and Long Short-Term Memory (LSTM). The results of our experiments show that our model is more accurate than the previous studies for predicting the severity. Our approach improves by 23.03%, 21.86%, and 20.59% of the average F-measure for Mozilla, Eclipse, and GCC by comparing with the Naïve Bayesian based approach which performs the best among all baseline approaches.

Role of Requirement Prioritization Technique to Improve the Quality of Highly-Configurable Systems

Highly-configurable systems are such systems which are not developed for single scenario. However, perhaps they have variable functionality and they are developed for hybrid scenarios. Producing a good highly-configurable system within time and with customer satisfaction is not easy. Handling requirements effectively in such a way that it take least time to market, is one of the most difficult tasks in highly-configurable system. In this paper, a quantitative requirement prioritization technique for highly-configurable systems is proposed. This technique involves all stakeholders and can be used primarily for large scale software projects. The proposed technique is evaluated by taking a case study of the highly-configurable point of sale for automotive industry. The result shows that the proposed technique provides promising results and can be enhanced with more future work.