Software Size Research Articles

The Economic Importance of Business Software Systems Functional Size Measurement

Execution of Business Software Systems (BSS) Development and Enhancement Projects (D&EP) encounters many problems, leading to the high scale of their failure, which then is reflected in considerable financial losses. One of the fundamental causes of such projects’ low effectiveness are improperly derived estimates for their costs and time. In their case, the budget and time frame are determined by the effort being spent on activities needed to deliver product that would be meeting client’s requirements. Meanwhile, objective and reliable effort estimation still appears to be a great challenge, what in the author’s opinion is caused by effort estimation based on resources, while such planning activity should base on the required software product size, which determines work effort. Estimation of BSS size requires using of the suitable software size measure, which has been sought for several decades now. What’s more, it is worth using the capabilities offered by such measure for the BSS D&EP assessment from the perspective being critical to a client, that is from functional perspective. Thus this paper analyses capabilities, being significant from the economic point of view, of taking advantage of suitable approach to the BSS size measurement, with particular consideration given to the two most popular functional size measurement methods normalized by ISO/IEC, namely International Function Point Users Group (IFPUG) method and Common Software Measurement International Consortium (COSMIC) method. This should contribute to the better understanding of the importance of this issue, still being underestimated by business managers – as in the subject literature this issue is usually considered from the technical point of view. Meanwhile, suitable BSS size measurement should constitute the basis for rational activities and business decisions not only for providers, but also for clients needs.

Probabilistic size proxy for software effort prediction: A framework

Software effort prediction is an important and challenging activity that takes place during the early stages of software development, where costing is needed. Software size estimate is one of the most popular inputs for software effort prediction models. Accordingly, providing a size estimate with good accuracy early in the lifecycle is very important; it is equally challenging too. Estimates that are computed early in the development lifecycle, when it is needed the most, are typically associated with uncertainty. However, none of the prominent software effort prediction techniques or software size metrics addresses this issue satisfactorily. In this paper, we propose a framework for developing probabilistic size proxies for software effort prediction using information from conceptual UML models created early in the software development lifecycle. The framework accounts for uncertainty in software size and effort prediction by providing the estimate as a probability density function instead of a certain value. We conducted a case study using open source datasets and the results were encouraging.

Towards an early software estimation using log-linear regression and a multilayer perceptron model

Software estimation is a tedious and daunting task in project management and software development. Software estimators are notorious in predicting software effort and they have been struggling in the past decades to provide new models to enhance software estimation. The most critical and crucial part of software estimation is when estimation is required in the early stages of the software life cycle where the problem to be solved has not yet been completely revealed. This paper presents a novel log-linear regression model based on the use case point model (UCP) to calculate the software effort based on use case diagrams. A fuzzy logic approach is used to calibrate the productivity factor in the regression model. Moreover, a multilayer perceptron (MLP) neural network model was developed to predict software effort based on the software size and team productivity. Experiments show that the proposed approach outperforms the original UCP model. Furthermore, a comparison between the MLP and log-linear regression models was conducted based on the size of the projects. Results demonstrate that the MLP model can surpass the regression model when small projects are used, but the log-linear regression model gives better results when estimating larger projects.

Approximation of COSMIC functional size to support early effort estimation in Agile

The demands in the software industry of estimating development effort in the early phases of development are met by measuring software size from user requirements. A large number of companies have adapted themselves with Agile processes, which, although, promise rapid software development, pose a huge burden on the development teams for continual decision making and expert judgement, when estimating the size of the software components to be developed at each iteration. COSMIC, on the other hand, is an ISO/IEC international standard that presents an objective method of measuring the functional size of the software from user requirements. However, its measurement process is not compatible with Agile processes, as COSMIC requires user requirements to be formalised and decomposed at a level of granularity where external interactions with the system are visible to the human measurer. This time-consuming task is avoided by agile processes, leaving it with the only option of quick subjective judgement by human measurers for size measurement that often tends to be erroneous. In this article, we address these issues by presenting an approach to approximate COSMIC functional size from informally written textual requirements demonstrating its applicability in popular agile processes. We also discuss the results of a preliminary experiment studying the feasibility of automating our approach using supervised text mining.

The Role of Class Diagram in Estimating Software Size

ne of the subjects related to software engineering is software measurement. Software measurement itself includes different topics that estimating software size is one of them. Various methods have been proposed for estimating software size. Each studies this topic from specific approach. Since UML is a well-known notation for representing object-oriented models, some of the methods are based on it. In this article, through describing class diagram, we consider the efficacy and role of class diagram in estimating software size. KeywordsMeasurement, Software size estimation, UML class diagram, Analysis object model, Static Modeling

Comparing Soft Computing Techniques For Early Stage Software Development Effort Estimations

Accurately estimating the software size, cost, effort and schedule is probably the biggest challenge facing software developers today. It has major implications for the management of software development because both the overestimates and underestimates have direct impact for causing damage to software companies. Lot of models have been proposed over the years by various researchers for carrying out effort estimations. Also some of the studies for early stage effort estimations suggest the importance of early estimations. New paradigms offer alternatives to estimate the software development effort, in particular the Computational Intelligence (CI) that exploits mechanisms of interaction between humans and processes domain knowledge with the intention of building intelligent systems (IS). Among IS, Artificial Neural Network and Fuzzy Logic are the two most popular soft computing techniques for software development effort estimation. In this paper neural network models and Mamdani FIS model have been used to predict the early stage effort estimations using the student dataset. It has been found that Mamdani FIS was able to predict the early stage efforts more efficiently in comparison to the neural network models based models.

소프트웨어 안전성 평가를 위한 소프트웨어 고장 유형과 영향 분석에 관한 연구

오늘날 대다수의 안전필수 시스템들(Safety-Critical Systems)에는 컴퓨터, 전기 및 전자 부품이나 장치들에 소프트웨어를 칩에 내장하거나 제어용 소프트웨어 시스템이 탑재되어 구축되고 있다. 이에 따라, 컴퓨터 소프트웨어를 내장하였거나 탑재한 시스템들의 안전성을 평가하기 위한 여러 가지의 결함 분석 기법들이 제안되어져 오고 있다. 이러한 소프트웨어 결함 분석 기법들은 전통적으로는 하나의 안전필수 시스템을 분석하는데 단지 하나의 방법으로만 분석해 왔으나, 시스템의 종류와 특성이 다양해지면서 그 시스템에 가장 알맞은 결함 분석 기법이 동원되어야 함은 필수적이다. 본 연구에서는, 안전필수 시스템에서 소프트웨어의 크기가 비교적 작고, 안전성과 관련한 시스템 제어 반응 시간이 특별히 민감하지 않는 소프트웨어의 안전성을 평가하는 방법으로 결함트리 분석(FTA)과 소프트웨어 고장 유형 및 영향 분석(FMEA)을 결합한 시스템 결함 분석 방법을 제안하고 유비쿼터스 헬스케어 시스템을 이용하여 사례연구를 수행하고자 한다. These days, most of safety-critical systems, which are systems those failures or malfunction may result in death or serious injury to people, or loss or severe damage to social systems, or environmental harm, are being built of embedded software or loaded controlling software systems on computers, electrical and electronic components or devices. There are a lot kind of fault analysis methods to evaluate safety of the safety-critical systems equipped computers, electrical and electronic components or devices with software. However, the only assessment method to evaluate software safety of a safety-critical system is not enough to analysis properly on account of the various types and characteristic of software systems by progress of information technology. Therefore, this paper proposes the integrated evaluation method and carries out a case study for the software safety of safety-critical system which embedded or loaded software sizes are small and control response times are not sensitive by use of two security analysis methods which are Fault Tree Analysis (FTA) and Fault Modes and Effect Analysis (FMEA) for ubiquitous healthcare system.

A comparative evaluation of effort estimation methods in the software life cycle

Even though there are a number of software size and effort measurement methods proposed in literature, they are not widely adopted in the practice. According to literature, only 30% of software companies use measurement, mostly as a method for additional validation. In order to determine whether the objective metric approach can give results of the same quality or better than the estimates relying on work breakdown and expert judgment, we have validated several standard functional measurement and analysis methods (IFPUG, NESMA, Mark II, COSMIC, and use case points), on the selected set of small and medium size real-world web based projects at CMMI level 2. Evaluation performed in this paper provides objective justification and guidance for the use of a measurement-based estimation in these kinds of projects.

Neural Networks for Accurate Estimation of Software Metrics

Nowadays, software requirements are widely increasing and modern software technologies are rapidly growing. Therefore, planning and managing the software projects are more important as compared to the past. Unsuitable project planning has been the main reason of software project fails in recent years. Estimating is performed at the early stages of project and it is one of the most important activities in software project planning. During the recent years many different methods have been proposed to estimate the software metrics. Software development effort and software size are most important metrics in this field. Since uncertain nature of software projects makes it difficult to estimate the metrics, soft computing techniques have been widely used in software metrics estimation. These techniques can improve the accuracy of estimations in software projects by means of neural networks, genetic algorithm, fuzzy logic and so on. Among all mentioned methods, due to high flexibility and adaptability, neural networks have been used more than the other methods. A comparative study can be useful to discriminate the performance of neural networks regarding the software metrics estimation. In this paper 15 previous research works in term of using neural networks for software estimation were investigated basically. Analyzing the selected research works showed that neural networks can estimate the software metrics more accurate than most common algorithmic methods.

An Analysis of Hybrid Tool Estimator: An Integration of Risk with Software Estimation

Problem statement: One important problem with software development projects is to get an early and nevertheless accurate estimation of the effort needed to complete the project within the schedule. In the literature various methods have been developed for this purpose. The most popular examples are Boehm’s COCOMO, Albrecht’s Function Point Method or Sneed’s object-point method. The two last named methods are based on early results of an analysis phase; whereas COCOMO is based on an a priori estimation of the software size in “Lines of Code”. Despite of the increasing needs and available tools and methods, a satisfactory solution is still to be found. During the last two years, has gained some interest in this community an approach based on hybrid technique of software estimation. Approach: In this study, we discuss that traditional Function Point Method does not cover the quality factors and the estimation is fully based on development of systems. Hence, the quality assurance factors were discussed in this study. The comparative analysis of the existing software estimations were also developed and compared with the developed model so that the efficiency of the model can be analyzed with the existing methods. The classification of software system for which the effort estimation is to be calculated is based on the COCOMO model classes. So, our aim is to develop a hybrid method which combines all the important parameters from the various existing method for effort estimation. Once the effort estimation has been found, the same have been extended to risk assessment techniques by considering various risk parameters. So, the developed hybrid model is an integrated model of estimation with risk assessment. Results: A software has been designed (Front End-Java, Back End-MS-ACCESS) which shows the comparison between the traditional Function point method and the proposed method. Conclusion: Detailed comparative analyses have been made based on the result for all the estimation techniques.

소프트웨어 비용-일정 타협을 위한 수정된 소프트웨어 공식

하나의 소프트웨어를 개발하기 위해서는 개발조직의 생산성, 투입되는 노력, 개발일정, 소프트웨어 규모 간에 관계가 있다. 이들 관계를 유도한 식이 소프트웨어 공식이다. 소프트웨어 공식은 근본적으로 규모-노력, 규모-일정 관계가 적용되었다. 이 관계가 적절하지 않을 경우 소프트웨어 공식으로부터 유도되는 비용-일정 타협 공식, 투입인력 프로파일 등의 효용성이 없어진다. 본 논문에서는 이러한 문제점을 해결하고자 수정된 소프트웨어 공식을 유도하였으며, 수정된 소프트웨어 공식에 기반하여 소프트웨어 규모별로 비용-일정을 타협하는 모델들을 제안하였다. 소프트웨어 개발 성공률을 향상시키기 위해 제안된 모델을 적용하면 계약 협상이나 입찰에 도움이 될 것이다. To develop a software, there is a relationship between development organization's productivity, effort, development schedule, and software size. It is software equation that motive these relations. Basically, relationship between size-effort and size-schedule is applied. If this relationship is not proper, there would be no effect of the cost-schedule tradeoff equation that is derived from software equation, and the manpower profile analysis, etc. To solve these unwanted problems, we presented a modified software equation and a cost-schedule tradeoff model based on the modified software equation. To improve software development success rate, applying proposed model will help in contract negotiation or bid.

A rule-based approach for estimating software development cost using function point and goal and scenario based requirements

Function point is a method used to measure software size and estimate the development cost. However, for large complex systems, cost estimation is difficult because of the large number of requirements expressed in natural language. In this paper we propose a rule-based approach for estimating software development cost in the requirements analysis phase. It combines goal and scenario based requirements analysis with function point based cost estimation. In our proposed approach, Context Analysis Guiding rules, Data Function Extraction Guiding rules, and Transaction Function Extraction Guiding rules have been developed to identify function points from text based goal and scenario descriptions. These rules are established based on a linguistic approach. The contribution of the proposed approach is to help project managers decide which requirements should be realized.

A Probabilistic Method for Predicting Software Code Growth

A significant challenge that many cost analysts and project managers face is predicting by how much their initial estimates of software development cost and schedule will change over the lifecycle of the project. Examination of currently-accepted software cost, schedule, and defect estimation algorithms reveals a common acknowledgment that estimated software size is the single most influential independent variable. Unfortunately, the most important business decisions about a software project are made at its beginning, the time when most estimating is done, and coincidently the time of minimum knowledge, maximum uncertainty, and hysterical optimism. This article describes a model and methodology that provides probabilistic growth adjustment to single-point Technical Baseline Estimates of Delivered Source Lines of Code, for both new software and pre-existing reused software that is sensitive to the maturity of their single-point estimates. The model is based on Software Resources Data Report data collected ...

A component model for hard real‐time systems: CCM with ARINC‐653

SUMMARYThe size and complexity of software in safety‐critical systems is increasing at a rapid pace. One technology that can be used to mitigate this complexity is component‐based software development. However, in spite of the apparent benefits of a component‐based approach to development, little work has been done in applying these concepts to hard real‐time systems. This paper improves the state of the art by making three contributions: (1) we present a component model for hard real‐time systems and define the semantics of different types of component interactions; (2) we present an implementation of a middleware that supports this component model. This middleware combines an open‐source CORBA Component Model (CCM) implementation (MICO) with ARINC‐653: a state‐of‐the‐art real‐time operating systems (RTOS) standard, (3) finally; we describe a modeling environment that enables design, analysis, and deployment of component assemblies. We conclude with a discussion of the lessons learned during this exercise. Our experiences point toward extending both the CCM as well as revising the ARINC‐653. Copyright © 2011 John Wiley & Sons, Ltd.

The value of software sizing

Context One of the difficulties faced by software development Project Managers is estimating the cost and schedule for new projects. Previous industry surveys have concluded that software size and cost estimation is a significant technical area of concern. In order to estimate cost and schedule it is important to have a good understanding of the size of the software product to be developed. There are a number of techniques used to derive software size, with function points being amongst the most documented. Objective In this paper we explore the utility of function point software sizing techniques when applied to two levels of software requirements documentation in a commercial software development organisation. The goal of the research is to appraise the value (cost/benefit) which functional sizing techniques can bring to the project planning and management of software projects within a small-to-medium sized software development enterprise (SME). Method Functional counts were made at the bid and detailed functional specification stages for each of five commercial projects used in the research. Three variants of the NESMA method were used to determine these function counts. Through a structured interview session, feedback on the sizing results was obtained to evaluate its feasibility and potential future contribution to the company. Results The results of our research suggest there is value in performing size estimates at two appropriate stages in the software development lifecycle, with simplified methods providing the optimal return on effort expended. Conclusion The ‘Estimated NESMA’ is the most appropriate tool for use in size estimation for the company studied. The use of software sizing provides a valuable contribution which would augment, but not replace, the company’s existing cost estimation approach.

ReMoFP: A Tool for Counting Function Points from UML Requirement Models

Function Point Analysis (FPA) is a widely used technique for measuring software size. It measures software functionality from the user's perspective, usually based on a requirements description. In many software processes, these requirements are represented by UML models. Although there have been attempts to automate the measurement process, FPA counting requires a considerable amount of interpretation which, to be reliable, should be made by experts. On the other hand, fully manual counting methods usually fail to keep synchronized with the requirements model, since requirements frequently change during the development cycle. This paper describes an approach for counting FPA and a compliant tool. This approach makes use of UML requirement models. The tool, called ReMoFP (Requirement Model Function Point counter), leaves all the counting decisions to the analyst, but supports him by ensuring consistency with the requirements represented in the models. The ReMoFP was developed by a software development laboratory in Brazil, and helped it to improve counting productivity, consistency, and maintainability.

Comparing Complexity in Accordance with Object Oriented Metrics

Metrics are essential in software engineering for measuring software complexity, quality, estimating size and project effort. The major techniques for software cost estimation are sizing or predication of various kinds of software deliverable items. The cost estimation techniques consists of various categories like tools and methods for estimating and measuring software size, function points, lines of code, and object points. This paper highlights the object-oriented software metrics proposed in 90s’ by Chidamber, Kemerer and several studies were conducted to validate the metrics and discovered several deficiencies. Further new object oriented metrics were proposed by Li. Chidamber, Kemerer proposed six software metrics as Weighted Methods per Class (WMC), Depth of Inheritance Tree (DIT), Number of Children (NOC) , Coupling Between Object classes (CBO), Response For a Class (RFC), Lack of Cohesion in Methods (LCOM). A new metrics suite for object-oriented programming proposed by Li includes Number of Ancestor Classes (NAC), Number of Local Methods (NLM), Class Method Complexity (CMC), Number of Descendent Classes (NDC), Coupling Through Abstract Data Type (CTA), and Coupling Through Message Passing (CTM) as an alternatives to Chidamber and Kemerer metrics. Here the comparisons have been made between the metrics proposed by Chidamber, Kemerer and Li.

A historical compilation of software metrics with applicability to NASA’s Orion spacecraft flight software sizing

Estimating the size of a large and complex software system is a challenging task. Early in a project's life cycle, when requirements for the system may be immature and functionality defined only at a high level, resource profiles are necessary for appropriate funding, staffing, and development of a viable project plan. Similar project historical software size data and trends provide a tool to predict software size, creating a feasible estimation approach. To confidently estimate the flight software required for the Orion Spacecraft, NASA conducted an analysis of similar space and aircraft software systems. This paper presents the results of a study that compiled data from over 400 spacecraft, aircraft, and submarine software projects, which were functionally similar in nature to the Orion spacecraft flight software. The study includes the analysis and summary of overall trends in software size, development strategies, and processes. The results indicate a well-correlated upward trend in software size over time for both crewed and uncrewed space and aircraft. This trend was used to predict the estimated completed size of the Orion flight software at approximately 2.3 million Source Lines of Code (SLOC).

Using Artificial Neural-Networks in Stochastic Differential Equations Based Software Reliability Growth Modeling

Due to high cost of fixing failures, safety concerns, and legal liabilities, organizations need to produce software that is highly reliable. Software reliability growth models have been developed by software developers in tracking and measuring the growth of reliability. Most of the Software Reliability Growth Models, which have been proposed, treat the event of software fault detection in the testing and operational phase as a counting process. Moreover, if the size of software system is large, the number of software faults detected during the testing phase becomes large, and the change of the number of faults which are detected and removed through debugging activities becomes sufficiently small compared with the initial fault content at the beginning of the testing phase. Therefore in such a situation, we can model the software fault detection process as a stochastic process with a continuous state space. Recently, Artificial Neural Networks (ANN) have been applied in software reliability growth prediction. In this paper, we propose an ANN based software reliability growth model based on Ito type of stochastic differential equation. The model has been validated, evaluated and compared with other existing NHPP model by applying it on actual failure/fault removal data sets cited from real software development projects. The proposed model integrated with the concept of stochastic differential equation performs comparatively better than the existing NHPP based model.

Software cost estimation for component-based fourth-generation-language software applications

Software cost estimation is important for budgeting, risk analysis, project planning and software improvement analysis. There are numerous estimation techniques. During the past three decades there had been some significant developments in effort estimation, size of software and cost estimation methodology. Current software cost estimation models have been experiencing increasing difficulties in estimating the costs of software, as new software development methodologies and technologies are emerging very rapidly. Most of the software cost models generally rely on such inputs as estimates of lines of source code, delivered sets of instructions, function points and processing complexity or experience levels to produce cost estimates. These models generally produce inaccurate results when used to estimate the cost of software development in current development environments such as those that use component-based software development environments like visual languages. The authors present in this study a new technique for software cost estimation that can be used for software projects developed using component-based fourth-generation-language environment. The model was calibrated using the empirical data collected from 19 software systems. Efficiency of the model was also compared with an existing model used for such environment. The proposed model achieved better predictive accuracy.