Software Development Projects Research Articles

Preliminary Estimation for Software Development Projects Empowered with a Method of Recommending Optimal Duration and Team Composition

In the early software development stages, the aim of estimation is to obtain a rough understanding of the timeline and resources required to implement a potential project. The current study is devoted to a method of preliminary estimation applicable at the beginning of the software development life cycle when the level of uncertainty is high. The authors’ concepts of the estimation life cycle, the estimable items breakdown structure, and a system of working-time balance equations in conjunction with an agile-fashioned sizing approach are used. To minimize the experts’ working time spent on preliminary estimation, the authors applied a decision support procedure based on integer programming and the analytic hierarchy process. The method’s outcomes are not definitive enough to make commitments; instead, they are supposed to be used for communication with project stakeholders or as inputs for the subsequent estimation stages. For practical usage of the preliminary estimation method, a semistructured business process is proposed.

Cost-Efficient Deployment Strategies: A Comparative Analysis of Feature Flagging Services and Blue/Green Deployments

Aims: This study provides a detailed comparison of two leading feature flagging services, LaunchDarkly and ConfigCat, and also examines the cost-efficiency and operational implications of using Blue/Green deployment strategies. It seeks to aid stakeholders in understanding the trade-offs and benefits of each approach to make informed decisions based on project-specific needs, budget constraints, and developmental objectives. Study Design:  The study employs a comparative analysis framework, focusing on features, usability, scalability, architectural design, and the financial impacts of adopting feature flagging services versus Blue/Green deployment strategies. Place and Duration of Study: The analysis was conducted over a period of two years, encompassing a broad range of software development environments and project scenarios to ensure comprehensive coverage and relevance. Methodology: The methodology employed in this paper includes a detailed examination of LaunchDarkly and ConfigCat's service offerings, an evaluation of Blue/Green deployment strategies, and an analysis of cost-efficiency of each approach. The study synthesizes information from product documentation, user feedback, and performance metrics, alongside interviews with industry experts and case studies from diverse software development projects. Results: The results highlight the nuanced differences between feature flagging services in terms of scalability, ease of use, and the suitability for various project sizes. LaunchDarkly emerges as optimized for large-scale, complex projects due to its extensive feature set and scalability, while ConfigCat is favored for its simplicity and ease of use in smaller projects. The analysis also uncovers the cost benefits of feature flagging over Blue/Green deployments, emphasizing the savings on infrastructure and operational expenses while offering dynamic feature management capabilities. Conclusion: The study concludes that the choice between feature flagging services like LaunchDarkly and ConfigCat, and the utilization of Blue/Green deployment strategies, should be guided by specific project requirements, financial constraints, and desired operational efficiency. Feature flagging services provide a cost-effective, flexible solution for dynamic feature management, whereas Blue/Green deployments offer a straightforward, though potentially more resource-intensive, approach to minimizing deployment risks. This comparative analysis aims to assist stakeholders in selecting the most appropriate deployment strategy to meet their development goals efficiently.

ScrumSpiral: An Improved Hybrid Software Development Model

In the lightning-quick world of software development, it is essential to find the most effective and efficient development methodology. This thesis represents "Scrum Spiral" which is an improved hybrid software development model that combines the features of Scrum and Spiral approach to enhance the software development process. This thesis aims to identify the usefulness of "ScrumSpiral" methodology and compare it with other hybrid software development models to encourage its use in software development projects. To develop this hybrid model, we did extensive research on the software engineering domain and decided to create a hybrid model by using Scrum and Spiral, named "Scrum Spiral" which is suitable for complicated projects and also for those projects whose requirements are not fixed. Traditional software development models face numerous challenges in rapidly changing markets. By developing this kind of hybrid model, we want to overcome these kinds of limitations and present the software development community with a novel concept for better project results. Final outcome of this thesis was that we developed a model that should be able to complete the project according to the expected schedule, satisfy customer requirements, and obtain productivity through team coordination. The significance of the hybrid model "Scrum Spiral" is reflected in its ability to offer flexibility towards various size projects, proactive risk management to identify all risks before developing the system, and result in higher-quality outcomes for those projects whose requirements are not properly described initially in the project.

Agile effort estimation in Colombia: An assessment and opportunities for improvement

Effort estimation is fundamental for the development of software projects and critical to their success. The objective of this paper is to understand how Colombian agile practitioners perform effort estimates and to identify opportunities for improvement based on these results. For this purpose, we conducted an exploratory survey study using as instrument an on-line questionnaire answered by agile practitioners with experience in effort estimation. Data was collected from 60 agile practitioners and the main findings are: (1) Agile practitioners prefer non-algorithmic estimation techniques, mainly those based on Expert Judgment. (2) Most of the respondents perceive that their estimates have a medium accuracy level; however, in most cases, no formal analysis of the accuracy level is carried out. (3) The determining effort predictors/cost drivers are characteristics of the project team (size, experience, and skills) and attributes of the software to be built (complexity, type, and domain). (4) The use of datasets for estimation is not common; proprietary datasets predominate and are used for productivity comparisons within the company. (5) Most of the results of related studies are comparable with ours; however, there are significant differences in terms of the roles involved and the techniques used in the effort estimation process. Based on the results and findings of the survey, we identified key opportunities to improve estimation accuracy through (1) software measurement standardization, (2) use of effort datasets, (3) implementation of techniques for measuring accuracy levels, and (4) knowledge management in effort estimation.

Agile meets quantum: a novel genetic algorithm model for predicting the success of quantum software development project

Quantum software systems represent a new realm in software engineering, utilizing quantum bits (Qubits) and quantum gates (Qgates) to solve the complex problems more efficiently than classical counterparts. Agile software development approaches are considered to address many inherent challenges in quantum software development, but their effective integration remains unexplored. This study investigates key causes of challenges that could hinders the adoption of traditional agile approaches in quantum software projects and develop an Agile-Quantum Software Project Success Prediction Model (AQSSPM). Firstly, we identified 19 causes of challenging factors discussed in our previous study, which are potentially impacting agile-quantum project success. Secondly, a survey was conducted to collect expert opinions on these causes and applied Genetic Algorithm (GA) with Naive Bayes Classifier (NBC) and Logistic Regression (LR) to develop the AQSSPM. Utilizing GA with NBC, project success probability improved from 53.17 to 99.68%, with cost reductions from 0.463 to 0.403%. Similarly, GA with LR increased success rates from 55.52 to 98.99%, and costs decreased from 0.496 to 0.409% after 100 iterations. Both methods result showed a strong positive correlation (rs = 0.955) in causes ranking, with no significant difference between them (t = 1.195, p = 0.240 > 0.05). The AQSSPM highlights critical focus areas for efficiently and successfully implementing agile-quantum projects considering the cost factor of a particular project.

Evaluating the Performance of Machine Learning Classifier Algorithms for Software Estimation in Software Development Projects

The major aim of this research is to rank the best performing features in order to classify the Software estimation dataset using SVM, Naïve Bayes, Random forest, Decision tree, and KNN classifiers and evaluate their accuracy. Two steps are involved in the classification process: first, the dataset with all attributes is analyzed; second, the information gain methodology is used to rank the attributes, and only the highly rated ones are used to generate the model of classification. Using several folds of cross-validation, we assess the accuracy rank of SVM, Naïve Bayes, Decision tree, Random forest, and KNN classifier

Technical risk model of machine learning based software project development - A multinational empirical study using modified Delphi-AHP method

ContextThe development of machine learning (ML) based software projects has increased significantly over the past decade, introducing new technical risks that rarely or never appear in traditional software development projects. ObjectiveThis research aims to identify and prioritize the technical risk factors that may lead to the failure of ML-based software development projects. MethodFirst, a literature review was conducted to compile a preliminary list of technical risk factors for ML-based software project development. Then, two rounds of the modified Delphi process were conducted with 17 ML experts to review and verify the completeness and appropriateness of the preliminary technical risk factors. A hierarchy of five technical risk categories with 22 technical risk factors was concluded for the analytic hierarchy process (AHP). Then, three rounds of online AHP questionnaires were administered. The consistency ratio (CR) was used to check the respondents’ answers, and the quartile deviation (QD) was applied to assess the consensus on all 96 questions. Finally, we prioritized the technical risk categories and associated technical risk factors. ResultsWe found that "data availability and quality" ranked as the top technical risk category in terms of severity, probability, and impact rankings of the five technical risk categories. Furthermore, all four technical risk factors within this category also occupied the top four positions of impact ranking. ConclusionThe research results highlight the crucial role of the four data availability and quality risk factors for the failure of ML-based software project development. The proposed technical risk model of ML-based software project development with the identified severity and probability priorities may provide practitioners and research community with a clear overview, highlighting areas demanding priority attention to effectively mitigate project failure risks. These findings have broader implications for improving the success rates of ML-based software projects across various domains.

A Conceptual Framework Based on PLS-SEM Approach for Sustainable Customer Relationship Management in Enterprise Software Development: Insights from Developers

Due to its significant relevance in outsourcing, the global software industry, such as enterprise software development organizations, accepted the implementation of global software development (GSD). Customers play a pivotal role in any industry, and effective customer relationship management (CRM) is instrumental in ensuring client satisfaction while developing software projects. However, software organizations operating globally often need more insight into their customers’ perspectives. These challenges give rise to a major combination for the success of the GSD projects. Organizations working globally face the key challenge of the implementation of CRM. The main objective of this paper is to investigate and understand the challenges faced by global software development organizations when implementing customer relationship management (CRM) in their enterprise software projects. This paper aims to assess how these CRM implementation challenges impact the value of enterprise software products in the context of global software development (GSD). To achieve this objective, the study employs the partial least squares-structural equation modeling (PLS-SEM) approach and conducts a systematic literature review (SLR) to identify relevant challenges. Additionally, this paper presents a conceptual framework based on the identified challenges and validates it through surveys and qualitative research with software outsourcing companies in Pakistan. The research provides valuable insights from the perspective of software developers and aims to offer practical guidance for the successful application of CRM in outsourcing.

Do Code Summarization Models Process Too Much Information? Function Signature May Be All What Is Needed

With the fast development of large software projects, automatic code summarization techniques, which summarize the main functionalities of a piece of code using natural languages as comments, play essential roles in helping developers understand and maintain large software projects. Many research efforts have been devoted to building automatic code summarization approaches. Typical code summarization approaches are based on deep learning models. They transform the task into a sequence-to-sequence task, which inputs source code and outputs summarizations in natural languages. All code summarization models impose different input size limits, such as 50 to 10,000, for the input source code. However, how the input size limit affects the performance of code summarization models still remains under-explored. In this paper, we first conduct an empirical study to investigate the impacts of different input size limits on the quality of generated code comments. To our surprise, experiments on multiple models and datasets reveal that setting a low input size limit, such as 20, does not necessarily reduce the quality of generated comments. Based on this finding, we further propose to use function signatures instead of full source code to summarize the main functionalities first and then input the function signatures into code summarization models. Experiments and statistical results show that inputs with signatures are, on average, more than 2 percentage points better than inputs without signatures and thus demonstrate the effectiveness of involving function signatures in code summarization. We also invite programmers to do a questionnaire to evaluate the quality of code summaries generated by two inputs with different truncation levels. The results show that function signatures generate, on average, 9.2% more high-quality comments than full code.

Consolidation of a New Organizational and Production Paradigm in Software Development Projects

Consolidation of a New Organizational and Production Paradigm in Software Development Projects

Causes and Mitigation Practices of Requirement Volatility in Agile Software Development

One of the main obstacles in software development projects is requirement volatility (RV), which is defined as uncertainty or changes in software requirements during the development process. Therefore, this research tries to understand the underlying factors behind the RV and the best practices to reduce it. The methodology used for this research is based upon qualitative research using interviews with 12 participants with experience in agile software development projects. The participants hailed from Austria, Nigeria, the USA, the Philippines, Armenia, Sri Lanka, Germany, Egypt, Canada, and Turkey and held roles such as project managers, software developers, Scrum Masters, testers, business analysts, and product owners. Our findings based on our empirical data revealed six primary factors that cause RV and three main agile practices that help to mitigate it. Theoretically, this study contributes to the body of knowledge relating to RV management. Practically, this research is expected to aid software development teams in comprehending the reasons behind RV and the best practices to effectively minimize it.

Stepwise migration of a monolith to a microservice architecture: Performance and migration effort evaluation

Due to scalability requirements and the split of large software development projects into small agile teams, there is a current trend toward the migration of monolith systems to the microservice architecture. However, the split of the monolith into microservices, its encapsulation through well-defined interfaces, and the introduction of inter-microservice communication add a cost in terms of performance. In this paper, we describe a case study of the migration of a monolith to a microservice architecture, where a modular monolith architecture is used as an intermediate step. The impact on migration effort and performance is measured for both steps. Current state-of-the-art analyses the migration of monolith systems to a microservice architecture, but we observed that migration effort and performance issues are already significant in the migration to a modular monolith. Therefore, a clear distinction is established for each of the steps, which may inform software architects on the planning of the migration of monolith systems. In particular, we consider the trade-offs of doing all the migration process or just migrating to a modular monolith.

Agile software development projects–Unveiling the human-related critical success factors

ContextInvestment in information technology is associated with better business performance when its implementation is successful, but it has high costs in case of failure, especially for large software development projects, which typically have the highest failure rates. Agile methodologies emerged with the expectation of reducing the risk of software development project failure. ObjectiveThis research aims to answer the following question: What are the human-related critical success factors for agile software development projects to succeed? The research model comprises four explanatory variables (team capability, customer involvement, psychological safety, and team autonomy) and one dependent variable (success of agile software development projects). MethodA questionnaire-based survey was carried out, resulting in 177 valid responses. A Partial Least Squares (PLS) analysis was performed to test the theoretical model. ResultsThe findings indicate that team capability and customer involvement have the strongest effects on the success of agile software development projects. The results also show that psychological safety is a significant indirect success factor and that team autonomy appears to have a competing dynamic with psychological safety on the other two factors. ConclusionTo the best of our knowledge, this is the first study to examine the direct impact of psychological safety and its indirect effect, mediated by team capability and customer involvement, on the success of agile software development projects. The mediation, moderation, and direct effects are studied, offering theoretical and practical insights.

Reasons for the Failure of Most In-House Software Development in Tanzania: A Case Study of Selected Higher Learning Institutions (HLIs)

Since it has evolved into an essential part of today’s world, 90% of Tanzanian businesses have attempted to develop in-house software for their operations. However, a substantial fraction of these projects haven’t quite achieved what they set out to. The bulk of in-house software development projects in Tanzania have been unsuccessful. This article presents ideas for improving the success rate of in-house software development initiatives and explains why this is the case. As part of the qualitative research methodology, software developers, project managers, and other stakeholders took part in focus groups and interviews. The results show that there are several factors, such as a lack of qualified staff, an inadequate budget allocation, poor project management, a lack of precise project requirements, improper communication, an inadequate amount of resources, and a lack of user involvement, that significantly contribute to the failure of in-house software development projects in Tanzania. The study makes numerous recommendations for enhancing the success rate of in-house software development initiatives in Tanzania. Involving end users throughout the project life cycle, implementing strong project management practices, allocating enough time and resources for software testing, hiring experts to establish and gather precise project requirements, allocating adequate budgets, and setting up efficient communication channels are a few examples of these. Additionally, in-house software development must adhere to the SDLC’s standards by enhancing the model of the SDLC that best suits the nature of the development process.

Optimization of use case point through the use of metaheuristic algorithm in estimating software effort

Use Case Points estimation framework relies on the complexity weight parameters to estimate software development projects. However, due to the discontinue parameters, it lead to abrupt weight classification and results in inaccurate estimation. Several research studies have addressed these weaknesses by employing various approaches, including fuzzy logic, regression analysis, and optimization techniques. Nevertheless, the utilization of optimization techniques to determine use case weight parameter values has yet to be extensively explored, with the potential to enhance accuracy further. Motivated by this, the current research delves into various metaheuristic search-based algorithms, such as genetic algorithms, Firefly algorithms, Reptile search algorithms, Particle swarm optimization, and Grey Wolf optimizers. The experimental investigation was carried out using a Silhavy UCP estimation dataset, which contains 71 project data from three software houses and is publicly available. Furthermore, we compared the performance between models based on metaheuristic algorithms. The findings indicate that the performance of the Firefly algorithm outperforms the others based on five accuracy metrics: mean absolute error, mean balance relative error, mean inverted relative error, standardized accuracy, and effect size.

Automated hearing impairment diagnosis using machine‐learning: An open‐source software development undergraduate research project

AbstractApproximately 700 million people will have disabling hearing loss by 2050. Underdeveloped and developing countries, which encompass a considerable proportion of people with disabling hearing impairment, have a sparse number of audiologists and otolaryngologists. The lack of specialists leaves most hearing impairments undiagnosed for a long time, resulting in negative societal and economic impacts. In this article, we propose an automated hearing impairment diagnosis software—based on machine learning—to support audiologists and otolaryngologists in accurately and efficiently diagnosing and classifying hearing loss. We present the design, implementation, and performance analysis of an open‐source automated hearing impairment diagnosis software, which consists of two modules: a hearing test data‐generation module and a machine‐learning model. The data‐generation module produces a diverse and exhaustive data set for training and evaluating the machine‐learning model. By employing multiclass and ultilabel classification techniques to learn from the hearing test data, the model can swiftly predict the type, degree, and configuration of hearing loss with high reliability. Our proposed machine‐learning model demonstrates promising results with a prediction time of 634 ms, a log‐loss reduction rate of 0.9848 and accuracy, precision, recall, and f1‐score of 1.0000—showing the model's applicability to assist audiologists and otolaryngologists in rapidly and accurately classifying the type, degree, and configuration of hearing loss. In addition to the technical contributions, this article also highlights the importance of involving undergraduate students in open‐source software development projects which have a direct impact on improving the quality of human life.

Detecting Ambiguities in Requirement Documents Written in Arabic Using Machine Learning Algorithms

The identification of ambiguities in Arabic requirement documents plays a crucial role in requirements engineering. This is because the quality of requirements directly impacts the overall success of software development projects. Traditionally, engineers have used manual methods to evaluate requirement quality, leading to a time-consuming and subjective process that is prone to errors. This study explores the use of machine learning algorithms to automate the assessment of requirements expressed in natural language. The study aims to compare various machine learning algorithms according to their abilities in classifying requirements written in Arabic as decision tree. The findings reveal that random forest outperformed all stemmers, achieving an accuracy of 0.95 without employing a stemmer, 0.99 with the ISRI stemmer, and 0.97 with the Arabic light stemmer. These results highlight the robustness and practicality of the random forest algorithm.

Software Effort Estimation using Machine Learning Algorithms

Effort estimation is a crucial aspect of software development, as it helps project managers plan, control, and schedule the development of software systems. This research study compares various machine learning techniques for estimating effort in software development, focusing on the most widely used and recent methods. The paper begins by highlighting the significance of effort estimation and its associated difficulties. It then presents a comprehensive overview of the different categories of effort estimation techniques, including algorithmic, model-based, and expert-based methods. The study concludes by comparing methods for a given software development project. Random Forest Regression algorithm performs well on the given dataset tested along with various Regression algorithms, including Support Vector, Linear, and Decision Tree Regression. Additionally, the research identifies areas for future investigation in software effort estimation, including the requirement for more accurate and reliable methods and the need to address the inherent complexity and uncertainty in software development projects. This paper provides a comprehensive examination of the current state-of-the-art in software effort estimation, serving as a resource for researchers in the field of software engineering.

Episodic organizational learning in system development

PurposeThis study aims to understand how practitioners use their insights in software development models to share experiences within and between organizations.Design/methodology/approachThis is a qualitative study of practitioners in software development projects, in large-, medium- or small-size businesses. It analyzes interview material in three-step iterations to understand reflexive practice when using software development models.FindingsThe study shows how work processes are based on team members’ experiences and common views. This study highlights the challenges of organizational learning in system development projects. Current practice is unreflective, habitual and lacks systematic ways to address recurring problems and share information within and between organizations. Learning is episodic and sporadic. Knowledge from previous experience is individual not organizational.Originality/valueSoftware development teams and organizations tend to learn about, and adopt, software development models episodically. This research expands understanding of how organizational learning takes place within and between organizations with practitioners who participate in teams. Learnings show the potential for further research to determine how new curriculums might be formed for teaching software development model improvements.

Mitigating Software Vulnerabilities through Secure Software Development with a Policy-Driven Waterfall Model

For the past few years, software security has become a pressing issue that needs to be addressed during software development. In practice, software security is considered after the deployment of software rather than considered as an initial requirement. This delayed action leads to security vulnerabilities that can be catered for during the early stages of the software development life cycle (SDLC). To safeguard a software product from security vulnerabilities, security must be given equal importance with functional requirements during all phases of SDLC. In this paper, we propose a policy-driven waterfall model (PDWM) for secure software development describing key points related to security aspects in the software development process. The security requirements are the security policies that are considered during all phases of waterfall-based SDLC. A framework of PDWM is presented and applied to the e-travel scenario to ascertain its effectiveness. This scenario is a case of small to medium-sized software development project. The results of case study show that PDWM can identify 33% more security vulnerabilities as compared to other secure software development techniques.