Quantifying the Impact of Different Non-functional Requirements and Problem Domains on Software Effort Estimation

2011 ◽  
Author(s):  
Rolan Abdukalykov ◽  
Ishrar Hussain ◽  
Mohamad Kassab ◽  
Olga Ormandjieva
Keyword(s):  
Effort Estimation ◽  
Functional Requirements ◽  
Software Effort Estimation ◽  
The Impact

scholarly journals Estimating Software Development Efforts Using a Random Forest-Based Stacked Ensemble Approach

Electronics ◽  
2021 ◽  
Vol 10 (10) ◽  
pp. 1195
Author(s):  
Priya Varshini A G ◽  
Anitha Kumari K ◽  
Vijayakumar Varadarajan
Keyword(s):  
Deep Learning ◽  
Random Forest ◽  
Software Development ◽  
Weighted Averaging ◽  
Software Project ◽  
Effort Estimation ◽  
Software Effort Estimation ◽  
Single Model ◽  
Ensemble Techniques ◽  
Project Estimation

Software Project Estimation is a challenging and important activity in developing software projects. Software Project Estimation includes Software Time Estimation, Software Resource Estimation, Software Cost Estimation, and Software Effort Estimation. Software Effort Estimation focuses on predicting the number of hours of work (effort in terms of person-hours or person-months) required to develop or maintain a software application. It is difficult to forecast effort during the initial stages of software development. Various machine learning and deep learning models have been developed to predict the effort estimation. In this paper, single model approaches and ensemble approaches were considered for estimation. Ensemble techniques are the combination of several single models. Ensemble techniques considered for estimation were averaging, weighted averaging, bagging, boosting, and stacking. Various stacking models considered and evaluated were stacking using a generalized linear model, stacking using decision tree, stacking using a support vector machine, and stacking using random forest. Datasets considered for estimation were Albrecht, China, Desharnais, Kemerer, Kitchenham, Maxwell, and Cocomo81. Evaluation measures used were mean absolute error, root mean squared error, and R-squared. The results proved that the proposed stacking using random forest provides the best results compared with single model approaches using the machine or deep learning algorithms and other ensemble techniques.

scholarly journals IoT-Based Patient Movement Monitoring: The Post-Operative Hip Fracture Rehabilitation Model

2021 ◽  
Vol 13 (8) ◽  
pp. 195
Author(s):  
Akash Gupta ◽  
Adnan Al-Anbuky
Keyword(s):  
Hip Fracture ◽  
Real Time ◽  
System Performance ◽  
Digital Health ◽  
Time Behavior ◽  
Functional Requirements ◽  
Rehabilitation Process ◽  
Rehabilitation Model ◽  
The Impact ◽  
Movement Monitoring

Hip fracture incidence is life-threatening and has an impact on the person’s physical functionality and their ability to live independently. Proper rehabilitation with a set program can play a significant role in recovering the person’s physical mobility, boosting their quality of life, reducing adverse clinical outcomes, and shortening hospital stays. The Internet of Things (IoT), with advancements in digital health, could be leveraged to enhance the backup intelligence used in the rehabilitation process and provide transparent coordination and information about movement during activities among relevant parties. This paper presents a post-operative hip fracture rehabilitation model that clarifies the involved rehabilitation process, its associated events, and the main physical movements of interest across all stages of care. To support this model, the paper proposes an IoT-enabled movement monitoring system architecture. The architecture reflects the key operational functionalities required to monitor patients in real time and throughout the rehabilitation process. The approach was tested incrementally on ten healthy subjects, particularly for factors relevant to the recognition and tracking of movements of interest. The analysis reflects the significance of personalization and the significance of a one-minute history of data in monitoring the real-time behavior. This paper also looks at the impact of edge computing at the gateway and a wearable sensor edge on system performance. The approach provides a solution for an architecture that balances system performance with remote monitoring functional requirements.

scholarly journals Are Multi-Language Design Smells Fault-Prone? An Empirical Study

2021 ◽  
Vol 30 (3) ◽  
pp. 1-56
Author(s):  
Mouna Abidi ◽  
Md Saidur Rahman ◽  
Moses Openja ◽  
Foutse Khomh
Keyword(s):  
Programming Languages ◽  
Language Design ◽  
Functional Requirements ◽  
Code Smells ◽  
Design And Implementation ◽  
Design Smells ◽  
The Cost ◽  
The Impact ◽  
Fault Proneness

Nowadays, modern applications are developed using components written in different programming languages and technologies. The cost benefits of reuse and the advantages of each programming language are two main incentives behind the proliferation of such systems. However, as the number of languages increases, so do the challenges related to the development and maintenance of these systems. In such situations, developers may introduce design smells (i.e., anti-patterns and code smells) which are symptoms of poor design and implementation choices. Design smells are defined as poor design and coding choices that can negatively impact the quality of a software program despite satisfying functional requirements. Studies on mono-language systems suggest that the presence of design smells may indicate a higher risk of future bugs and affects code comprehension, thus making systems harder to maintain. However, the impact of multi-language design smells on software quality such as fault-proneness is yet to be investigated. In this article, we present an approach to detect multi-language design smells in the context of JNI systems. We then investigate the prevalence of those design smells and their impacts on fault-proneness. Specifically, we detect 15 design smells in 98 releases of 9 open-source JNI projects. Our results show that the design smells are prevalent in the selected projects and persist throughout the releases of the systems. We observe that, in the analyzed systems, 33.95% of the files involving communications between Java and C/C++ contain occurrences of multi-language design smells. Some kinds of smells are more prevalent than others, e.g., Unused Parameters , Too Much Scattering , and Unused Method Declaration . Our results suggest that files with multi-language design smells can often be more associated with bugs than files without these smells, and that specific smells are more correlated to fault-proneness than others. From analyzing fault-inducing commit messages, we also extracted activities that are more likely to introduce bugs in smelly files. We believe that our findings are important for practitioners as it can help them prioritize design smells during the maintenance of multi-language systems.

Sign in / Sign up

Export Citation Format

Share Document