• Journal of KIISE:Software and Applications
• /
• v.29 no.12
• /
• pp.873-882
• /
• 2002

Estimation of development cost, effort and time is difficult and a key problem of software engineering in the early stage of software development. These are estimated by using the function point which is measured from a requirement specification. However, it is often a serious Question of the staffing level required for the software development. The purpose of this paper is to show us the model which can be used to estimate a size of development team. Three hundred one software projects have been analyzed and studied for the model. First, an analysis was conducted for statistical algorithmic model. After various data transformation and regression analysis, it was concluded that no good model was available. Therefore, non-algorithmic model was suggested for analysis, which has random distribution of residuals and makes good performance using RBF (Radial Basis Function) network. Since the model provides a standard to determine the required size of development team, it ran be used as management information.

• The Transactions of the Korean Institute of Electrical Engineers P
• /
• v.65 no.4
• /
• pp.242-249
• /
• 2016

The railway system is being converted to the computer system from the existing mechanical device, and the dependency on software is being increased rapidly. Though the size and degree of complexity of software for railway system are slower than the development speed of hardware, it is expected that the size will be grown bigger gradually and the degree of complexity will be increased also. Accordingly, the validation of reliability and safety of embedded software for railway system was started to become influential as the important issue. Accordingly, various software test and validation activities are highly recommended in the international standards related railway software. In this paper, we presented a software coding analysis tool using symbolic execution for railway system, and presented its result of implementation.

• The KIPS Transactions:PartD
• /
• v.9D no.4
• /
• pp.603-612
• /
• 2002

Area of software measurement in software engineering is active more than thirty years. There is a huge collection of researches but still no concrete software development effort and cost estimation model. If we want to measure the effort and cost of a software project, we need to estimate the size of the software. A number of software metrics are identified in the literature; the most frequently cited measures are LOC (line of code) and FPA (function point analysis). The FPA approach has features that overcome the major problems with using LOC as a measure of system size. This paper presents simple linear regression model that related software development effort to software size measured in FP. The model is derived from the plotting of the effort and FP relation. The experimental data are collected from 789 software development projects that were recently developed under the various development environments and development methods. Also, the model is compare with other regression analysis model. The presented model has the best estimation ability among the software effort estimation models.

• Korean Journal of Artificial Intelligence
• /
• v.11 no.1
• /
• pp.17-24
• /
• 2023

With the continuous growth in the amount of data collected and analyzed, deep learning has become increasingly popular for extracting meaningful insights from various fields. However, hardware limitations pose a challenge for achieving meaningful results with limited data. To address this challenge, this paper proposes an algorithm that leverages the characteristics of convolutional neural networks (CNNs) to reduce the size of image datasets by 20% through smoothing and shrinking the size of images using color elements. The proposed algorithm reduces the learning time and, as a result, the computational load on hardware. The experiments conducted in this study show that the proposed method achieves effective learning with similar or slightly higher accuracy than the original dataset while reducing computational and time costs. This color-centric dataset construction method using image smoothing techniques can lead to more efficient learning on CNNs. This method can be applied in various applications, such as image classification and recognition, and can contribute to more efficient and cost-effective deep learning. This paper presents a promising approach to reducing the computational load and time costs associated with deep learning and provides meaningful results with limited data, enabling them to apply deep learning to a broader range of applications.

• The KIPS Transactions:PartD
• /
• v.11D no.3
• /
• pp.597-604
• /
• 2004

Accurate software cost estimation is essential to both developers and customers. Most of the cost estimating models based on the size measure methods, such as LOC and FP, are obtained through size estimation. The accuracy of size estimation directly influences the accuracy of cost estimation. As a result, the overall structure of regression-based cost models applies the power function based on software size. Many growth phenomenon in nature such as the growth in living organism, performance of technology, and learning capability of human show an S-shaped curve. This paper proposes a model which estimates the developing effort by using the growth curve. The presented model assumes that the relation cost and size follows the growth curve. The appropriateness of the growth curve model based on Function Point, Full-Function Point and Use-Case Point, which are the general methods in estimating the software size have been confirmed. The proposed growth curve model shows similar performance with power function model. In conclusion, the growth curve model can be applied in the estimation of the software cost.

• The KIPS Transactions:PartD
• /
• v.8D no.3
• /
• pp.241-246
• /
• 2001

Area of software measurement in software engineering is active more than thirty years. There is a huge collection of researches but still no a concrete software cost estimation model. If we want to measure the cost-effort of a software project, we need to estimate the size of the software. A number of software metrics are identified in the literature ; the most frequently cited measures are LOC(line of code) and FPA(function point analysis). The FPA approach has features that overcome the major problems with using LOC as a measure of system size. This paper presents an neural networks(NN) models that related software development effort to software size measured in FPs and function element types. The research describes appropriate NN modeling in the context of a case study for 24 software development projects. Also, this paper compared the NN model with a regression analysis model and found the NN model has better estimative accuracy.

• The KIPS Transactions:PartD
• /
• v.12D no.3 s.99
• /
• pp.409-416
• /
• 2005

Even though development paradigm of software has been changing very fast at the beginning of 21st Centuries, there are just few studies of quality and estimation metrics appropriate for Web environment. So in this study after analyzing the correlation between the size of the final code and property of objects, three industrial real world projects written in ASP have been used for deriving programs with high possibilities of faults. And then the size of programs was analyzed to correlate with the number of classes or the number of methods through linear regression. Among the web software with the complex architecture or server, client and un, type or form file written in Javascript for client has the high correlation and the number of methods is well correlated with the size of final code.

• Journal of Communications and Networks
• /
• v.13 no.1
• /
• pp.1-5
• /
• 2011

Feedback with carry shift registers (FCSRs) over 2-adic number would be suitable in hardware implementation, but the are not efficient in software implementation since their basic unit (the size of register clls) is 1-bit. In order to improve the efficiency we consider FCSRs over $2^{\ell}$-adic number (i.e., FCSRs with register cells of size ${\ell}$-bit) that produce ${\ell}$ bits at every clocking where ${\ell}$ will be taken as the size of normal words in modern CPUs (e.g., ${\ell}$ = 32). But, it is difficult to deal with the carry that happens when the size of summation results exceeds that of normal words. We may use long variables (declared with 'unsigned _int64' or 'unsigned long long') or conditional operators (such as 'if' statement) to handle the carry, but both the arithmetic operators over long variables and the conditional operators are not efficient comparing with simple arithmetic operators (such as shifts, maskings, xors, modular additions, etc.) over variables of size ${\ell}$-hit. In this paper, we propose some conditions for FCSRs over $2^{\ell}$-adic number which admit fast software implementations using only simple operators. Moreover, we give two implementation examples for the FCSRs. Our simulation result shows that the proposed methods are twice more efficient than usual methods using conditional operators.

• Journal of Information Technology Services
• /
• v.18 no.4
• /
• pp.39-53
• /
• 2019

This article analyzes the effects of regulation that restrict the conglomerate firms to participate in the public procurement of software. The regulation was implemented in 2013, and this article analyzes five years of firm performance before and after 2013 through DID (difference-in-difference method). In particular, this article analyzes how restrictions on conglomerate firms' participation in public software procurement affect middle and small firms performance. As a result, small-size firms achieve relatively positive results in private sector revenues compared to mid-size firms. However, there was no significant difference between the mid-size and small-size firms in profit margin. This study implies that the new policy is needed to improve the small and medium-size firms revenues on the private market by leveraging the public procurement market which restricted the conglomerate firms to participate. This can be done by complementing the regulation in line with servitization paradigm.

• Journal of Korea Society of Industrial Information Systems
• /
• v.4 no.3
• /
• pp.1-7
• /
• 1999

An important task for any software project manager is to be able to predict and control project size. Unfortunately, there is comparatively little work that deals with the problem of building prediction methods for software size in fourth-generation languages and database projects. In this paper, we propose a new estimation method for estimating for software size based on minimum relative error(MRE) criterion. The characteristic of the proposed method is insensitive to the extreme values of the observed measures which can be obtained early in the development life cycle. In order to verify the performance of the proposed estimation method for software size in terms of both quality of fit and predictive quality, the experiments has been conducted for the dataset Ⅰ and Ⅱ, respectively. For the data set Ⅰ and Ⅱ, our proposed prediction method was shown to be superior to the traditional method LS and RLS in terms of both the quality of fit and predictive quality when applied to data obtained from actual software development projects.