Fuzzy and Mathematical Effort Estimation Models for Web Applications Development

This paper proposed an Effort Estimation Model for optimizing the deployment of Web Applications Based Fuzzy and Practical Models. This paper presented the effort estimation model that involves two levels—the first level estimates by Project Managers, and the second level estimates by Project Leaders or Developers. The model considers the classification of each task as either Low or Medium or High complexity. Efforts are estimated to design, code, and test tasks and take a new requirement as a case study, compared with the practical efforts model using historical data for the existing functionalities. The fuzzy logic model verifies the claims made in effort estimation, which proposed a new relation between data and effort value membership for actual data. It converts it into a crisp function in the range [0…1], which helps classify the task's complexity and subtask in the design, coding, and testing phases quickly, low cost, and high accuracy. The proposed effort estimation model would allow the project managers to efficiently control the project, manage the resources effectively, improve the software development process, and trade-off analyses time.


Introduction
The effort estimation is considered as one of the important activities in software development project management.
Several researchers have been discussed and modeled the association between software development's main factors, like size and efforts (Al Asheeri & Hammad, 2019). Nerveless, all these efforts, but still many problems need to solve and still. These problems usually happened in the early phases of a project, such as inconsistent, uncertain, and unclear data. The enhancement of the effort estimation phase is considered a vital tool for software development planning and forecasting the time and cost of developing a software project system (Huang, Ho, Ren, & Capretz, 2007). Creating low-price software development is regarded as an essential feature to produce competitive software. The relation between the need for reliable and accurate software in one direction and the prediction software cost is a challenging Thamarai (Thamarai, Murugavalli, & Technology, 2016) introduces a software effort estimation based on a differential evolution algorithm called DEAPS, which is examined on the Desharnais dataset. The results prove that the proposed method develops the ability of exploration. Bardsiri (Bardsiri et al., 2013) introduces a hybrid estimation model based on a particle swarm optimization (PSO) algorithm and an Analogy-based estimation (ABE). This study obtained accurate estimates of results based on categorical and non-categorical datasets. Also, it helps to improve the performance of existing estimation models. This paper's main focus is to build a fuzzy effort estimation model for design, development, and the unit test of a web application, either new or enhancement. This model will estimate based on the effort data available for past releases.

Existing Effort Estimation Model
The existing effort estimation model for design and development establishes a pattern that resembles features to be implemented in the new enhancement (Kumar, Behera, Kumari, Nayak, & Naik, 2020). The model compares the practices implemented in earlier releases and finds out a close match. The effort required to implement the matched pattern(s) in the previous releases is used to predict the future effort (Saini & Yousif, 2018). The patterns are matched based on specific metrics like (the Number of controls added, Number of files accessed, and Nature of database access).
The web application is classified under various modules like: • Graphical User Interface Design like adding, modifying and deleting controls • Graphical User Interface Functionality • Database schema • Generation of Reports • Data Import • Less/more data centric changes Based on the requirement analysis, details are worked out in existing patterns, and the estimation is derived for every new enhancement. A data repository is already available, which has the efforts of design and development for various patterns. The model's drawbacks are that it is difficult to measure the similarity levels between the current requirements and those implemented in the past. When the requirements for a feature consists of a small set of tasks like modifying a data element based on a configuration parameter, the estimates were pretty accurate. On the other hand, if the requirements are called for many tasks, then the estimation is made with this model were highly inaccurate (Pandey, Litoriya, & Pandey, 2020). Also, the effort required to arrive at an estimate was very high, and hence it was considered unproductive. The model provides the estimation in terms of person days, which does not usually reflect the correct effort in person-hours.

Proposed Effort Estimation Model
This paper's main focus is to build a fuzzy effort estimation model for design, develop, and the unit test of a web application, either new or enhancement. This model will estimate based on the effort data available for past releases.
The model is based on each task's complexity, which assumes that the task complexity is either low or medium or high. Each level of complexity also has three sub-levels of complexity. So, there are nine levels of complexity for any task (Du, Ho, & Capretz, 2015). Each group of complexity is assigned the effort in terms of person hours for design, coding and unit testing.
The effort involves a bottom-up approach where a task is broken into several subtasks. The subtask could be developed using SQL Server programs or VB programs or ASP program, or any combination (Arnuphaptrairong, Circuits, & Systems, 2013). The efforts of all the subtasks are added to get the total effort required for a task. The total effort for design, coding, and unit testing of each pattern is calculated for any repeated units.

Data Collection
The design corresponding to each of the features implemented in a major release for the repository holds the data of programs written in Active Server Pages. The commands executed in the branding example are illustrated in Appendix 1. The estimation process aims to measure historical projects' attributes to arrive at a bottom-up effort estimation model. Bottom-up estimation begins with the lowest level parts of products or tasks to provide estimates for each. Then these estimates are combined to arrive at the higher-level estimates. The effort spent on each subtask is summed in each developer's timesheet that implemented the feature. So, the subtasks were interpreted for a given feature, and complexity was assigned to each subtask. For example, let us consider a feature that was implemented to add search criteria to the web application. The requirement was to search all the corporate cardholders based on their First Name and Last Name. The subtasks to implement this feature are: 1. Add form elements are corresponding to the first name and last name in an ASP page. (Technically, this means adding two text boxesone for the First Name and the other for Last Name) 2.Add a JavaScript function to validate the user entries into these form elements (Technically, this means a new function needs to be written in JavaScript in the ASP page to validate for entries in mandatory fields and presence of special characters) 3. Modify a JavaScript function submit the form (In the existing web application, a JavaScript function already exists to submit forms to the server. This function needs to be modified to include this new ASP page) 4. Add new stored procedure in SQL Server to return the set of cardholders based on the input (i.e., First Name and/or Last Name) -Corresponds to writing a query to retrieve results from two tables 5. Modify a VB method to call the above-stored procedure by passing the parameters viz-first Name and Last Name, using a Command Object. 6. Adding a server-side function in ASP to display the cardholders (Server-side functions are written in VB script in the web application discussed) Each of these subtasks is assigned a complexity as shown below.
• SubTask 2 -Low Complexity. The author's organization's set of guidelines is followed wherever the time sheets did not reflect the subtasks correctly after identifying the subtasks belonging to each category. Low, medium, and high, the effort required for each subtask is computed from the timesheet. Appendix 1 shows that to add processes such as "add a new search criterion", the effort taken works out to 20.5 person hours as detailed below.

Soft Computing & Fuzzy Systems
Soft Computing (SC) is a new computing technique for utilizing real-world problems and provides lower-cost solutions. It mainly consists of the following methods: neural networks, fuzzy systems, and evolutionary computation.

Implementation of the Estimation Model (Case Study)
This effort estimation model is used to estimate the effort based on new requirements in vogue. The estimated effort has been compared with the actual effort for three of the features implemented. The description of these three features is described below.
1. Branding Changescorresponds to Graphical User Interface Design changes 2. Modification to Reportscorresponds to more data centric utility 3. Handling of transaction disputescorresponds to Graphical User Interface Functionality.
As a case study, let us consider the estimation for branding changes.
The requirements for the branding changes are the following: Based on Appendix 2, the estimation for the design effort is as given in Table 1. The branding changes involved development is worked only in ASP pages, the estimation was done by taking the values listed for ASP pages in each sub task. The Table 3 illustrates a case studyeffort estimation for coding based on practical calculations.
The total effort estimated for coding works out to 204.6 person hours. The actual effort was 189 person hours. The variance works out to about 8.2%. The Table 3 depicts the use case of the calculation effort estimation unit in testing phase. The estimated total effort for unit testing works out to 69.5 person hours. The actual effort was 88 hours. The variance works out to about 26.6%. Based on the above comparison between estimated effort and actual effort, it can be concluded that the effort estimation model can be used to estimate with a variance of about 25%. This variance is very much acceptable for first level estimation.
The practical and estimation calculation shows that the complexity of branding changes is only medium and high.
But this is not reflecting the real case of the efforts spend in different stages. For example, if the user wants to add 8 new menu items, then the estimated effort is 5.5 (the first row in Table 1), and complexity is high. While if the user wants to add 12 new sub-menu items first, then the estimated effort is 7.5 (the second row in Table 1), and complexity is medium. This will make a vague understanding of the meaning of complexity values. Now, we will calculate the estimation of efforts based on the Fuzzy model.   The fuzzy model's implementation is discussed, and the case study of the effort estimation for design in Table 1 is implemented as a fuzzy model as depicted in Figure 1. Table 4 presents the relationship between the amount of data in the application and the basic estimation efforts parameters. The membership function must be computed and transferred as a crisp function in the range of [0…1] as depicted in Table 5.   Crisp Value Case Number Figure 3 shows the MSE for training and cross-validation for the Fuzzy logic model. It is giving evidence that the output of the fuzzy model closely fits the desired data. The data sets are divided into three categories (60 % as training data sets, 20% as cross-validation data sets, and 20% as testing data sets). The model achieved a final MSE of (0.0647) in the training phases, and it is reached a minimum MSE of (0.0017) as summarized in The same transformation will be implemented for the other rules for coding, design and testing.

Conclusion and Recommendations
The effort estimation model discussed in this paper focuses on estimating the effort of design, coding, and unit testing, and the first level estimates are within a variance of about 25%. The variance would improve for second level estimates and is expected to be about 15%. Estimation must be as closer as possible.
The results can also be compared with estimates calculated using function points and other methods that use regression. The first level estimates computed using the effort estimation model have a variance of about 25% compared with the actual effort. This variance is very much acceptable considering that the first level estimates can be tolerable by up to 35%. The proposed effort estimation tool would help the project managers efficiently control the project, manage the resources effectively, and improve the software development process and trade-off analyses among schedule, performance, quality, and functionality. A Soft Computing approach is implemented, and results are verified using the Fuzzy Logic models, which compute the complexity accurately and quickly. A serious problem in the effort estimation models that some subtasks did not use before hasn't any complexity yet. Using the fuzzy models can quickly compute these tasks' complexity and then estimate the effort needed to build the application. Using a fuzzy model helps calculate the complexity of different tasks like design, coding, and testing.