Software Size Research Articles

Dynamic creation of source code models for the extraction of code metrics data through grammar querying

• A novel methodology for aiding the source code metrics extraction process. • Is based on the creation of dynamic tree data models as source code representation. • The tree data models are created from querying the programming language grammar. • The methodology is programming language and programming paradigm independent. Source code metrics extraction is a complex task that has to be done automatically given the current size of software. They are extracted using software metric tools and more generic extraction mechanisms. These mechanisms usually work by querying a source code representation model. These models are static, and the information that can be obtained from them is limited. In this work an extraction methodology is presented in which the model is created every time certain information is needed. This is accomplished by querying the language context-free grammar, and from the information obtained by the query, a dynamic model is created. Current extraction mechanisms work by querying a model, while the proposed methodology queries the grammar directly, thus the model is created afterwards from the query result, and contains all the needed information. A metrics tool is created based on the proposed methodology, and in order to prove the correct functioning of extracting the desired information from the source code, not as already predefined as in current tools, several metrics are extracted as defined by four existing metrics tools. Querying the language grammar allows access to all available data in the source code, regardless of the programming language and paradigm.

Adapting Recursive Sinusoidal Software Oscillators for Low-power Fixed-point Processors

The growing field of the Internet of Things relies at the bottom on components with very scarce computing resources that currently do not allow complex processing of sensed data. Any computation involving Fast Fourier Transforms (FFT), Wavelet Transforms (WT), or simple sines and cosines is considered impractical on low-end devices due to the lack of floating point and math libraries. This article presents new techniques that make it possible to use these functions also on severely constrained target platforms. Current literature abounds with schemes to compute sine and cosine functions, with focus on speed, hardware footprint, software size, target type, or precision. Even so, there is no practical exploration of the design space available for embedded devices with limited resources, in particular when only integer operations are possible. We select an efficient set of recursive sine and cosine generators and measure the frequency, amplitude, and phase error over a wide parameter range. We show that their simplicity allows them to be implemented on the most bare targets with good precision, reducing power consumption and size while being the fastest on integer-only processors. We also introduce specially tailored FFT and WT algorithms and show that they are usable in practice while having an extremely small code footprint, good precision, and high speed.

On an optimal analogy-based software effort estimation

Context: An analogy-based software effort estimation technique estimates the required effort for a new software project based on the total effort used in completing past similar projects. In practice, offering high accuracy can be difficult for the technique when the new software project is not similar to any completed projects. In this case, the accuracy will rely heavily on a process called effort adaptation, where the level of difference between the new project and its most similar past projects is quantified and transformed to the difference in the effort. In the past, attempts to adapt to the effort used machine learning algorithms; however, no algorithm was able to offer a significantly higher performance. On the contrary, only a simple heuristic such as scaling the effort by consulting the difference in software size was adopted. Objective:More recently, million-dollar prize data-science competitions have fostered the rapid development of more powerful machine learning algorithms, such as the Gradient boosting machine and Deep learning algorithm. Therefore, this study revisits the comparison of software effort adaptors that are based on heuristics and machine learning algorithms. Method:A systematic comparison of software effort estimators, which they all were fully optimized by Bayesian optimization technique, was carried out on 13 standard benchmark datasets. The comparison was supported by robust performance metrics and robust statistical test methods. Conclusion:The results suggest a novel strategy to construct a more accurate analogy-based estimator by adopting a combined effort adaptor. In particular, the analogy-based model that adapts to the effort by integrating the Gradient boosting machine algorithm and a traditional adaptation technique based on productivity adjustment has performed the best in the study. Particularly, this model significantly outperformed various state-of-the-art effort estimation techniques, including a current standard benchmark algorithmic-based technique, analogy-based techniques, and machine learning-based techniques.

Impact of Design Patterns on Software Complexity and Size

Many different factors influence the quality of software. Among the most important of these factors is software complexity. One way to improve software quality, therefore, is to minimize its complexity making it more understandable and maintainable. The design phase of the software development life cycle plays an instrumental role in fostering quality in software. Seasoned designers often use past design best practices codified in the form of design patterns to make their designs and the resultant code more elegant, robust, and resilient to change. Little work, however, has been done to empirically assess the quantitative impact of design patterns on software complexity. This research is an attempt to fill this gap. A comparative analysis of before and after versions of program pairs written without and with design patterns was performed for all twenty three GoF (Gang of Four) design patterns. These program pairs were collected (or, in some cases, developed) and compared with respect to their complexity and size. The results of this comparative analysis reveal that the cyclomatic complexity of the programs written using design patterns was less for most of the design patterns as compared to the programs written without using design patterns. However, the values of CK metrics, number of classes, and software size SLOC (Source Lines of Code) increased when design patterns were used.

Assessing the effectiveness of approximate functional sizing approaches for effort estimation

Context: Functional Size Measurement (FSM) methods, like Function Points Analysis (FPA) or COSMIC, are well-established approaches to estimate software size. Several approximations of these methods have been recently proposed as they require less time/information to be applied, however their effectiveness for effort prediction is not known. Objective: The effectiveness of approximated functional size measures for estimating the development effort is a key open question, since an approximate sizing approach may miss to capture factors affecting the effort. Therefore, we empirically investigated the use of approximate FPA and COSMIC sizing approaches, also compared with their standard versions, for effort estimation. Method: We measured 25 industrial software projects realised by a single company by using FPA, COSMIC, two approximate sizing approaches proposed by IFPUG for FPA (i.e. High Level and Indicative FPA), and three approximate sizing approaches proposed by the COSMIC organisation for COSMIC (i.e. Average Functional Process, Fixed Size Classification, and Equal Size Band). Then we investigated the quality of the regression models built using the obtained measures to estimate the development effort. Results: Models based on High Level FPA are effective, providing a prediction accuracy comparable to the one of the original FPA, while those based on the Indicative FPA method show poor estimation accuracy. Models based on COSMIC approximate sizing methods are also quite effective, in particular those based on the Equal Size Band approximation provided an accuracy similar to the one of standard COSMIC. Conclusion: Project managers should be aware that predictions based on High Level FPA and standard FPA can be similar, making this approximation very interesting and effective, while Indicative FPA should be avoided. COSMIC approximations can also provide accurate effort estimates, nevertheless, the Fixed Size Classification and Equal Size Band approaches introduce subjectivity in the measurement.

Effort estimation of open source Android projects via transaction analysis

AbstractTransactions have been used in many software sizing methods to measure software functional size and provide a basis for effort estimation. To further investigate the effects that transactions have on software functional size and more accurately estimate project effort using the transactional information, in this paper, we propose a method to identify transactions, as well as their complexity attributes that are influential to software functional size, directly from the source code of Android projects using static and dynamic analyses.The identified transactions are classified into different complexity levels and applied with different weights based on their evaluated complexity levels to distinguish their effects on software functional size. A size metric called sum of weighted transactions (SWT) is proposed to measure software functional size. We calibrate an effort estimation model using SWT based on a data set of 34 open source Android projects, and show the effectiveness of using SWT as a software functional size measure to estimate project effort.

Estimasi Biaya Perangkat Lunak Pada Aplikasi SIBIMA Universitas XYZ dengan Menggunakan Metode Function Point

The growing development of computers triggers the amount of software in different amounts and uses. A system is said to be good when starting planning that can estimate the cost, time and amount of resources needed as a basis for planning a system. So that the estimated cost can be an element in an assessment. The research explains that the Academic Guidance Information System (SIBIMA) which is a system for carrying out student consultation activities with academic advisers at XYZ University. From the software cost estimation results at SIBIMA use Function Point which is a method of estimating software size using an indirect approach or indirect approach to estimate software size in Function Point units (FP), for Effort values on SIBIMA is 379,906 man / hour and it is known that the cost needed in developing SIBIMA is IDR 22,858,705 so that it can be used as a reference if the higher education institution wants to develop a software system

Optimization of Interval Type-2 Fuzzy Logic System for Software Reliability Prediction

Since real world application is fraught with high amount of uncertainty, such as applicable to software reliability, there should be a method of handling the uncertainty. This paper presents a model to properly handle uncertainty in software data for effective prediction of the reliability of software at the early phase of software development process. In this paper we employed a Takagi-Sugeno-Kang (TSK)-based interval type 2 fuzzy logic systems with artificial neural network learning for the prediction of software reliability. The degree of membership grades of the interval type 2 fuzzy sets (IT2FSs) are obtained using interval type Gaussian membership function with fixed mean and uncertain standard deviation. The parameters of the IT2FLS membership functions are optimized using gradient descent (GD) back-propagation algorithm. As inputs to the system, reliability relevant software requirement metrics and the software size metrics are used. The proposed new approach makes use of qualitative data of requirement metrics of twenty three real software projects to examine its predictive ability. The performance of the model is evaluated using five performance metrics and found to provide better results when compared with existing approaches.

Evolutionary neural network classifiers for software effort estimation

The estimation of software development efforts has become a crucial activity in software project management. Due to this importance, many researchers focused their efforts on proposing models for relationship construction between efforts and software size and requirements. However, there are still gaps and problems in software effort's estimation process; due to the lack of enough data available in the initial stage of project life cycle. The need for an enhanced and an accurate method for software effort estimation is an urgent issue that challenged software project-management researchers around the world. This work proposes a model based on artificial neural network (ANN) and dragonfly algorithm (DA), in order to provide more accurate model for software effort estimation. The applicability of the model was evaluated using several experiments and the results were in favour of the enhancement with more accurate effort estimation.

Empirical Study of Function Point Analysis during Software Development Phase

During the development of the software, Software Requirement Changes (SRC) often occurs. Software estimation helps in maintaining a balance between the increase and decrease of the price, time, etc. Function Point Analysis (FPA) is a software effort estimation technique used for measuring the size and complexity of software by calculating the functionality from a user's point of view. Function count focuses on what functionality is being delivered. It enables programmers to perform function point counting themselves instead of contacting an expert. An empirical study has been conducted to analyze the capability of the FPA technique. The results of the FPA-SDP (Function Point Analysis for Software Development Phase) model can help software project managers in (i) knowing the inconsistent states of software artifacts (ii) estimating the actual size of a change request with its complexity level for the software development phase.

System performance requirements: A standards-based model for early identification, allocation to software functions and size measurement

Background: In practice, the developers focus is on early identification of the functional requirements (FR) allocated to software, while the system non-functional requirements (NFRs) are left to be specified and detailed much later in the development lifecycle. Aim: A standards-based model of system performance NFRs for early identification and measurement of FR-related performance of software functions. Method: 1) Analysis of performance NFR in IEEE and ECSS standards and the modeling of the identified system/software performance functions using Softgoal Interdependency Graphs. 2) Application of the COSMIC-FSM method (e.g., ISO 19761) to measure the functional size of the performance requirements allocated to software functions. 3) Use of the COSMIC-SOA guideline to tailor this framework to service-oriented architecture (SOA) for performance requirements specification and measurement. 4) Illustration of the applicability of the proposed approach for specification and measurement of system performance NFR allocated to the software for an automated teller machine (ATM) in an SOA context. Results: A standards-based framework for identifying, specifying and measuring NFR system performance of software functions. Conclusion: Such a standards-based system performance reference framework at the function and service levels can be used early in the lifecycle by software developers to identify, specify and measure performance NFR.

BEST PRACTICES AND RECOMMENDATIONS FOR WRITING GOOD SOFTWARE

Writing good software is not an easy task, it requires a lot of coding experience and skills. Therefore, inexperienced software developers or newbies suffer from this critical task. In this paper, we provide guidelines to help in this important context. It presents the most important best practices and recommendations of writing good software from software engineering perspective regardless of the software domain (whether for desktop, mobile, web, or embedded), software size, and software complexity. The best practices provided in this paper are organized in taxonomy of many categories to ease the process of considering them while developing software.  Furthermore, many useful, practical, and actionable recommendations are given mostly in each category to be considered by software developers

Determination of value price or computer application using function point analysis method

Some developer very capable of developing good quality working applications, but they don’t have the right value and price for their products, and it is because they did not use the right method to calculate the size of the product and valuate them correctly, most of them use analogy and expert judgment to perform their product sizing and valuation. This situation will create inconsistency in doing the pricing and it will create disadvantages for both developers and users. Function point analysis provides a methodology to perform software size calculation using algorithmic approaches that gives comprehensive and consistent results. In this document, I will explain step by step the processes of calculating the Function point using FPA procedures by implementing calculation formula of EI, EO, EQ, ILF, EIF, and VAP. I also will implement them to calculate the size of the “XIbar” application system, especially module customer care and customer info. By doing all these activities I hope will provide simple templates and procedures for calculating the size of application software that can be used easily by developers, students, and others who need it.

Relative risk proneness in phases of software development: metric based approach with Cox model

The software suffers from confounding effect due to defects that occurs during its entire development process. Software failure occurs due to various reasons. One of the reasons can be removal of defects at a much later stage, even though it has been detected in early phases of software development. Defect prediction has emerged as an interesting area for researchers within stipulated time period. Prediction depends mainly on the modeling of these defects and while modeling the simplest parameter used by researchers is the software size. In this paper, we showed deployment of Cox model and investigated the significance on defect prediction during various phases of development. The parameter used here is the defect count in various phases. Next, we proposed and compared two strategies for effective overall risk prediction of the projects using another proposed metric “Relative Risk Proneness Probability”. This metric is used in phases as evaluation criteria for judging the cost effectiveness of the project.

How software size influence productivity and project duration

<p>To make a perfect project plan, the software size of the order from the customer is the most important factor. The biggest challenge for the project manager is to estimate the project end date in the beginning of the project i.e. in project planning phase with realistic accuracy. Apart from other major inputs to estimate the project end date, expected team capability (productivity) and estimated software size are the major inputs that may influence the project end date. Software size is one of the most significant independent metric available in the planning phase and project manager has to estimate the other metrics based on the initial estimated software size. There is no direct relationship available between software size and project duration or software size and team productivity, however, there are industry data published by Quantitative Software Management and ISBSG that shows how these metrics influence each other. In this paper, using the data published by ISBSG and Quantitative Software Management, we try to statistically establish how productivity and project duration are influenced by software size. We have done linear regression analysis by generating the secondary data based on the data published by ISBSG and Quantitative Software Management. Linear regression equation validated with the actual project data and experimental results suggest that that productivity is significantly dependent on software size, however, project duration does not significantly depend on software size but may also be dependent on other metrics like team size, apart from software size.</p>

NEURO FUZZY COGNITIVE CONNECTION FUNCTIONAL POINT FOR ENTERPRISE NETWORK MANAGEMENT

Software effort estimation (SEE) is one of the vital roles in enterprise management. This created SEE process used to minimise the incomplete data involvements. It may require large amount of data, which increases the efficiency of the effort estimation system. So, in this paper introduces the enterprise data analytics process by using the size and judgmental software effort estimation process. This method analyses the effort in terms of using expert's opinions, use case, functional points and software size unit information. This method evaluates the neuro fuzzy cognitive connection-based functional points are used to estimates the effort with effective manner. This method examines the connectivity between one requirement to another requirements and it constructs the relationship graph that eliminates the incomplete requirements and details successfully. It reduces the time for examining the software effort. Then the performance of the system is calculated with the support of experimental results such as MRE and VAF.

Increasing the Reliability of Software Timing Analysis for Cache-Based Processors

Real-time systems are witnessing a significant increase in critical software's size, complexity, and performance needs, which can only be satisfied with high-performance hardware features. Cache memories, pervasively used to improve average performance, complicate Worst-Case Execution Time analysis: cache placement (i.e., how software objects are mapped to cache) during the testing phase does not only critically affect the observed performance, but also proves to be arduous to control and preserve up to operation. The probabilistic variant of Measurement-Based Timing Analysis (MBPTA) responds to this challenge by deploying time-randomized caches that naturally explore a different random cache placement in each run, relieving the user from producing tests that intercept relevant Cache Conflict Placements (CCP). Yet, to meet an adequate probabilistic CCP coverage, the user is required to collect a minimum number of measurements. We present two mechanisms, CCP-RM and CCP-HRP, to identify CCP with relevant probability of occurrence and large impact on execution-time, for the random modulo (RM) and hash-based random placement (HRP) policies. CCP-RM and CCP-HRP enable a reliable application of MBPTA by computing the number of runs $R^{\prime }$R' necessary to meet the desired CCP coverage. We exhaustively evaluate CCP-RM and CCP-HRP, showing their effectiveness on well-known benchmarks and a railway case study, on top of an accurate simulator and a concrete RTL implementation.

Combining Model-Based Testing and Failure Modes and Effects Analysis for Test Case Prioritization: A Software Testing Approach

Due to The complexity of modern software projects and the increasing size of software systems, it becomes difficult to manually perform tests with limited resources. Also, manual testing cannot assure that the software is tested using all possible combinations of inputs. Therefore, automate software testing activities have become primordial in the Software Development Life Cycle (SDLC). Model-based testing is a prominent validation technique in software testing that uses models of the system under test to automatically generate test cases; this generation leads to a large number of test cases; which cannot exhaustively be executed, due to time and cost constraints. Moreover, the test-cases execution order has an influence on the rate at which faults can be detected. Therefore, it is essential to prioritize test cases in order to execute the most important with limited time and cost. On the other hand, The Failure Mode and Effects Analysis (FMEA) considered as one of the formal techniques to do risk based testing. It offers a structured methodology to identifying the system failure modes, analyzing their effects and setting up controls to risk reducing and improve the quality of systems or products. By applying such a technique to Model-based testing projects, we can benefit from FMEA analysis and the automating in same project. Through this paper, we introduced a new model based testing approach for prioritizing and ranking test cases according to the requirements and failure modes. In the suggested approach we used the Failure Mode and Effect Analysis methodology in model based testing way to automatically generate a set of pair {test case, priority number} to prioritize test cases. It differs from existing approaches in that it generates two types of test cases; requirement-based test cases and failure mode-based test cases. For the purpose of experimental evaluation and analysis, we will compare the suggested approach with some well-known prioritization methods and we will present a case study to illustrate the potential application of the proposed approach in a future work.

A Study of Function Point Analysis: Some Suggestive Modifications

FPA (Function Point Analysis) is a standardized method aimed at establishing a software size measurement from its functional requirements, considering the features to be implemented in it. It was designed to be applied regardless of the programming language and implementation technology. The paper focuses on the requirements of the modification in the FPA. As from its origin to date there has been drastic changes occurred in the software development paradigm, but FPA exist in its previous form, so there is a need of examine the FPA with the current scenario.

Investigating the Relationship Between SLOC and Logical Database Measures to Improve the Early Estimation of Software Cost

Project planning is a critical activity in the software development life cycle. At the early stages of a project, the managers need to estimate required time, effort and cost to plan, track and then to deliver the project successfully. Many studies have attempted to provide methods for precise software cost estimation. The current software cost estimation methods are mainly based on software size estimation and functional system requirements. The main assumption of this study is that, as the primary source of complexity in today’s software is the interaction between the database and the user, database measures may provide inputs allowing current software estimation methods to achieve more accurate results. Accordingly, this study attempts to gain insights from objective measures, collected through the logical database model of software systems, for better prediction of the software’s effort and hence cost through software lines of code (SLOC) measure. For this purpose, more than 2.5 million lines of code developed by four different companies, for 79 different software packages with their related database design measures, are analyzed. The results of this study show that there is a close correlation between the software size and database design measure, namely, the number of tables which can be collected at the logical database design stage. By adapting this result, the current estimation models could be improved significantly.