Generation of a New Complexity Dimension Scheme for Complexity Measure of Procedural Program

Transcription

1 Geeratio of a New Complexity Dimesio Scheme for Complexity Measure of Procedural Program Nikhar Tak, Dr. Navee Hemrajai Departmet of Computer Sciece & Egg, Suresh Gya Vihar Uiversity,Jaipur Abstract - Software complexity measuremet has bee a agelog quadary i software egieerig as the effort used to develop, comprehed, or retai the software depeds o so may complicated factors. Measurig ad cotrollig of complexity will have a importat ifluece to improve productivity, quality ad maiteace of software. So far, most of the researches have tried to idetify ad measure the complexity i desig ad code phase. However, whe we have the code or desig for software, it is too late to cotrol complexity ad leads iaccuracy publishig i the whole system. I this paper, we propose a ew dimesio scheme, i the first phase i.e. Requiremet phase of software developmet which is based o software requiremet specificatios. Keyword Code based complexity measures, Cogitive complexity measures ad ew scheme for complexity measure. 1. INTRODUCTION Complexity is a feature of a computer program much like storage space ad speed of executio. It is the mai factor that ca lead to defects. The problem of reliability is basically the problem of software complexity. Whe the complexity reaches some thresholds, the defects or faults of the software grow rapidly. The maitaiability of the software is also havig tight correlatio with complexity. Complexity cotrol ad maagemet have importat roles i risk maagemet, cost cotrol, reliability predictio, ad quality improvemet. The complexity ca be classified i two parts: problem complexity (or itrisic complexity) ad solutio complexity (also referred to as additioal complexity). Solutio complexity is added durig the developmet stages followig the requiremets phase, mostly durig the desigig ad codig phase. May researchers suppose that software complexity is made up of the followig complexity: Problem complexity, which measures the complexity of the critical problem. This type of complexity ca be traced back to the requiremet phase, whe the problem is defied. Algorithmic complexity, which reflects the complexity of the algorithm implemeted to resolve the problem. Structural complexity reflects the complexity of the algorithm implemeted to solve the problem. Cogitive complexity measures the effort required to uderstad the software. Algorithmic complexity measured implemeted algorithm to solve the problem ad is based o mathematical methods. This complexity is computable as soo as a algorithm of a solutio is created, usually durig the desig phase. Structural complexity is composed of data flow, cotrol flow ad data structure. Some metrics are proposed to measure this type of complexity, for example McCabe cyclomatic complexity(that directly measures the umber of liear idepedet paths withi a module ad cosidered as a correct ad reliable metric), Hery ad Kafura metric(measures the iformatio flow to/from the module are measured, high value of iformatio flow represet the lack of cohesio i the desig that will cause higher complexity) ad Halstead metric (which is based o the priciple of cout of operators ad operad ad their respective occurreces i the code amog the primary metrics, ad is the strogest idicator i determiig the code complexity). There are some metrics based o cogitive methods [8] such as KLCID complexity metric (It defies idetifiers as the programmer defied variables ad based o idetifier desity. To calculate it, the umber of uique program lies is cosidered). To prevet slayig helpful resources ad complexity, it is better to focus o early stages of the software life cycle. Therefore, the result of idetifyig complexity factors is low costs ad high quality i software developmet ad particularly i maiteace stages of software. By kowig these factors, we try to prevet occurrig them or establish ew measure i requiremet phase. [7] Requiremets form the foudatio of the software developmet process. Loose foudatio brigs dow the whole structure ad weak requiremets documetatio leads to project failure. Recet surveys suggest that 40% to 85% of all defects are iserted i the requiremets phase. Thus, if errors are ot idetified i the requiremets phase, it is leadig to make mistakes, wrog product developmet ad loss valuable resource. Well-defied requiremets will icrease the probability of the overall success of the software project ad later stages of software developmet rely heavily o the quality of requiremets, there is a good reaso to pay close attetio to it. This paper aims to assessmet ad poit out the blemish of existig measures ad propose a ew measure i early phase of SDLC

2 2. CODE BASED COMPLEXITY MEASURES Code based complexity measures, as its ame is idicatig are based o the code of the program. Code based measures are typically depeds upo the program sizes, program flow graphs, or module iterfaces such as Halstead s software sciece metrics [2] ad the most widely kow measure of cyclomatic complexity developed by McCabe [3]. However, Halstead s software metrics purely calculates the umber of operators ad operads, but it does ot cosider the iteral structures of modules, while McCabe s cyclomatic complexity does ot cosider I/O s of a system as it is based o the flow chart of the program. It uses flow chart of the program ad o the basis of odes ad edges it provides complexity of the program. 2.1 Halstead Complexity Measure Halstead complexity [4] metrics is established for measurig program complexity with accet o computatioal complexity. Halstead metric, directly measure the complexity from the source code ad based o four umeric values as followed: 1: Number of o-recurrig operators 2: Number of o- recurrig operads N1: Number of all operators N2: Number of all operads Further Legth ad Vocabulary serve as the basis for fidig out Volume, Latet Volume, Difficulty, effort ad fially Time by usig equatios (1-7): Legth N = N1+ N2 (1) Vocabulary = 1+ 2 (2) Volume V = log 2 (3) Latet Volume V * (2+2) = (2 + 2) log 2 (4) Difficulty D =V * /V (5) Effort E = V/D (6) Time T= E/18 (7) The mai problem with this method or we ca say blockage with this is that it does ot distiguish the differeces amog the same operators ad amog the same operads i a program. Moreover, it igores the ested structure ad fails to aalyze the case statemet whe code is ot accessible. Other drawback with the Halstead metric is that they are difficult to compute, especially i large programs. 2.2 Mac Cabe s Cyclometric Complexity McCabe s cyclomatic complexity also kow as coditioal complexity based o cotrol flow. It deotes the umber of liearly idepedet paths through a program s source code [10] [3]. This measure provides a sigle ordial umber that ca be used to measure the complexity of differet programs The metric is calculated by usig equatio (8): CC = e + p (8) Here, e is the edges of graph, is the odes of graph, p is the o-coected parts of the graph. Aother formula for calculatig complexity is the followig: CC = Number of Decisios +1 It ca be computed early i life cycle tha of Halstead's metrics but there are some difficulties with the McCabe metric [6]. Although o oe would argue that the umber of cotrol paths relates to code complexity, some argue that this umber is oly part of the complexity picture. Accordig to McCabe, a 5,000-lie program with six IF/THEN statemets is less complex tha a 500-lie program with seve IF/THEN statemets ad this shows the complexity of ucotrolled statemet are igored. 3. COGNITIVE COMPLEXITY MEASURES I cogitive iformatics, the fuctioal complexity of software i desig ad comprehesio is depedet o fudametal factors such as iputs, outputs, Loops/braches structure, ad umber of operators ad operads [5]. 3.1 KLCID Complexity Metrics Klemola ad Rillig proposed KLCID which defies idetifiers as programmer's defied labels. It defies the use of the idetifiers as programmer defied variables ad idetifiers (ID) whe software is built up [5] [13]. ID = Total o. of idetifiers/ LOC I order to calculate KLCID, we eed to fid the umber of uique lies of code i a module, lies that have same type ad kid of operads with same arragemets of operators would be cosider equal. I defie KLCID as KLCID= No. of Idetifier i the set of uique lies/ No. of uique lies cotaiig idetifier This is a time cosumig method whe comparig a lie of code with each lie of the program. KLCID accepts that iteral cotrol structures for differet software s are idetical. 3.2 Cogiitive Fuctioal Size (CFS) Wag proposed a Cogitive Fuctioal Size (CFS) state that the complexity of software is depedet o iputs, outputs, ad its iteral processig [9]. As Where, CFS = (N i + N o ) * Wc N i = No of iputs. N o = No of outputs. Wc =The total cogitive weight of software The cogitive weight of software [11] is the degree of itricacy or relative time ad attempt for comprehedig give software modeled by a umber of Basic cotrol structures (BCS). 3.3 Cogitive Iformatio Complexity Measure Cogitive Iformatics plays a importat role i uderstadig the fudametal characteristics of software. CICM [12] is defies as the product of weighted iformatio cout of software (WICS) ad the cogitive weight (W c ) of the BCS s i the software i.e, CICM = WICS * W c Where, WICS is sum of weighted iformatio cout of lie of code (WICL). WICL for k th lie of code is give by [9]: WICL k =ICS k / [LOCS-k] 260

3 Where, ICS k iformatio cotaied i software for k th lie of code LOCS: total lies of code. Further ICS is give by: LOCS ICS= Σ (I k ) k=1 Where, I k is the iformatio cotaied i K th lie of code ad calculated I k = (Idetifiers + Operads) k Note that, similar to KLCID CICM is also difficult ad complex to calculate. It calculates the weighted iformatio cout of each lie. I their formulatio they claim that CICM is based o cogitive iformatics the fuctioal complexity of software oly deped o iput, output ad iteral architecture ot o the operators. Further they claimed that iformatio is a fuctio of idetifiers ad operators. It is difficult to uderstad that how they claimed that iformatio is fuctio of operators [5]. Operators are ru time attributes ad caot be take as iformatio cotaied i the software. 4. PROPOSED COMPLEXITY MEASURE Code based complexity measures such as Halstead Complexity Measure ad Mc Cabe s Cyclomatic Complexity Measure are based o the source code of the procedural programs. O the other had Cogitive based complexity measures such as Kids of Lies of Code Idetifier Desity (KLCID), Cogitive Fuctioal Size (CFS) ad Cogitive Iformatio Complexity Measure (CICM) deped o the iteral architecture of the procedural programs [1]. Thus both the methods will wait for the source code of the program ad take more time to get implemeted. It will be more beeficial if we ca calculate the complexity of the procedural programs i the earlier phases of the software developmet life cycle at the time of prelimiary assessmet that is requiremet aalysis. New dimesio scheme cosists of some of the attributes that must be studied at the time of software requiremet specificatio o the basis of which procedural program is to be developed. So the merit of this approach is that it is able to estimate the software complexity i early phases of software developmet life cycle, eve before aalysis ad desig is carried out. Due to this fact this is a cost effective ad less time cosumig. It ca be implemeted by cosiderig the various attributes such as: 4.1 Key I Out (KIO) KIO ca be defie as KIO = No. of Iputs + No. of outputs + No. of files + No of iterfaces 4.2 Fuctioal Requiremet (FR) Fuctioal requiremets should defie the elemetary trial that must take place. This ca be defied as FR = No. of Fuctios * SPF i i=1 Here, SPF is Sub Process or Sub-fuctios available after decompositio. 4.3 No Fuctioal Requiremet (NFR) It refers to the system qualitative requiremets ad ot satisfyig those leads to customer's dissatisfactio. This ca be represeted as NFR = Cout j Table Differet Types of No Fuctioal Requiremet 4.4 Obligatory Complexity Measure (OC) This ca be calculated by the sum of all fuctioal ad its decompositio ito sub-fuctios ad o fuctioal requiremets OC = FR + NFR 4.5 Special Complexity Attributes (SCA) This is referred to as the Cost Driver Attributes of uique Category from COCOMO Itermediate model proposed by Berry Boehm. Mathematically defied as i=1 5 SCA = MF i = 1 Here, MF is a Multiplyig Factor. 4.6 Desig Costraits Obligatory (DCO) It refers to the umber of costraits that are to be cosidered durig developmet of software. Represeted as DCO = C i i=0 Where C i is Number of Costraits ad value of C i will vary from 0 to. C i = 0 If Blid Developmet. C i = No-Zero If Costraits exists

4 4.7 Iterface Complexity (IFC) This parameter is used to defie umber of exteral iterfaces to the proposed program. IFC = I f Here I f is Number of Exteral Iterfaces ad value of I f will vary from 0 to. I f = 0 No Exteral Iterface. I f = No-Zero If Exteral Iterface exists 4.8 Users / Locatio Complexity (ULC) This parameter discuss the umber of users for accessig the program ad locatios (Sigle or Multiple) use. This ca be symbolized as i=0 ULC = No. of User * No. of Locatio 4.9 Program Feature Complexity (PFC) If advacemet of the program is to be doe the some features are added ad this parameter shows the program feature complexity by multiplyig all the features that have bee added ito it. Thus mathematical represetatio is as follows PFC = (Feature 1 * Feature 2 *. * Feature ) Now by cosiderig all these parameter ad defiig a ew measure that is SRS orieted complexity measure. It ca be mathematically show as SRSO = ((KIO + OC) * SCA + (DCI + IFC + PFC))* ULC The SRS Based Complexity will be higher for the programs, which have higher fuctioality to be performed ad more quality attributes which is to be retaied. All above measure have bee illustrated with the help of a example below Example 1: Develop a procedural program to eter 5 umbers at a time & display them i reverse order of the iput. Cosider this aim to upo goig through the SRS; we are able to extract the followig parameters Number of Iputs 05(Numbers) Number of Outputs 05(Reverse sequece of umbers) Number of Iterfaces 01(User Iterface) Number of Files 01(Storage of values) KIO = =12 Number of fuctio = 0 FR = 0 Number of No Fuctioal Requiremet (NFR) = 06 Obligatory Complexity (OC) = FR + NFR OC = 06 Special Complexity Attribute (SCA) = 0.90 (Suppose Programmer Capability = High) Desig Costraits Imposed (DCI) = 00 (No directives) DCI= 0 Iterface Complexity (IFC) = 0 Sice this program is ot to be further coected with ay exteral iterface Number of User / Locatio (ULC) = 1 * 1= 01 Program Feature Complexity (PFC) = 0 Now, OCM = ((KIO + OC) * SCA + (DCI + IFC + PFC))* ULC SRS Orieted Complexity Measure = The complexity measured by SRS Orieted Complexity Measure for the give SRS is 16.20, ow program code is illustrated i Program 1. Based o the above code we compute the complexity of the other proposed measures as show i Table 4.2 ad 4.3. Program 1: Program to Eter 5 Number at a time & Display them i Reverse Order of the iput. #iclude<stdio.h> #iclude<coio.h> void mai() { it i, x[5]; clrscr(); for (i=0;i<5;i++) { pritf("eter the umber\"); scaf("%d",&x[i]); } pritf("\the reverse order is\"); for (i=4;i>=0;i--) { pritf("\%d",x[i]); } getch(); } KLCID CFS CICM ID 6 N i 5 LOC 18 LOC 18 N o 5 Idetifier 6 ID 0.34 BCS (Seq.) 1 BCS (For 3 SBCS Loop) 7 No. of exceptioal Lies havig Idetifier No. of Idetifier i the set of exceptioal Lies 6 BCS (For Loop) Table 4.2 Calculatio for code ad cogitive complexity measure 3 12 W c 7 WICS 2.49 KLCID 0.50 CFS 70 CICM

5 Table 4.3 Calculatio for code ad cogitive complexity measure Mc Cabe Nodes 9 Edges 10 Predicate Node 5. COMPARISION BETWEEN VARIOUS COMPLEXITY MEASURES SRSO is applied o a program developed i C laguage ad used to eter 5 umbers at a time & display them i reverse order of the iput.i order to aalyze the validity of the result; the SRSO is calculated o the basis of SRS ad further compared with other established measures which are based o Code ad Cogitive complexity. I order to show compariso result a chart is cosidered Regios 2 Halstead N 1 36 N 2 07 Vocabulary 22 Program Legth 42 Effort Time V(G) 3 Halstead Difficulty Halstead KLCID CICM Figure 5.1 Compariso amog various complexity measures This graph cosist both code ad cogitive based complexity measures alog with the SRS orieted complexity measure for a procedural program for display reverse of 5 umbers. I other methods that are code ad cogitive complexity measure the source code of the program is eeded but i SRS orieted complexity measure time i waitig for codig is saved as it gauge the complexity at the time of very first phase of software developmet life cycle that is requiremet aalysis phase i which software requiremet specificatio is built up ad this also improves the quality of the program as Desig Costraits Obligatory (DCO), Iterface Complexity (IFC), Users / Locatio Complexity (ULC), Program Feature Complexity (PFC) are differet parameters that are also calculated for the program ad this other iformatio is gathered i SRS phase so quality of program is icreased as most of the parameters are very well kow ad calculated earlier. While other complexity measures will wait for the source code of the program ad eve the there is o way to calculate desig costraits, iterface eeded, locatio of accessig the program or umber of users who ca access program ad ay program features calculatig parameter. CONCLUSION I this paper, the drawbacks of existig software complexity measures were aalyzed such as Halstead measure the mai problem with this is that it does ot distiguish the differeces amog the same operators ad amog the same operads i a program. Other drawback with the Halstead metric is that they are difficult to compute, especially i large programs; a difficulty with the McCabe metric is it igored the complexity of ucotrolled statemet. Likewise whe we aalyze the cogitive complexity measures such as KLCID complexity metrics we foud that it is very time cosumig; similar to KLCID Cogitive Iformatio complexity measure (CICM) is also difficult ad complex to calculate because it calculates the weighted iformatio cout of each lie. Further CICM claimed that iformatio is a fuctio of idetifiers ad operators. It is difficult to uderstad that how they claimed that iformatio is fuctio of operators. Operators are ru time attributes ad caot be take as iformatio cotaied i the software. Thus we preseted a ew qualitative method to measure the complexity of procedural programs which is applicable before codig phase i.e, SRS Orieted Complexity Measure. It is useful for procedural programs as it is implemeted at requiremet phase of software developmet life cycle. So, it is ot depeded o the codig phase to be completed ad developig cost ad resources will be saved too. At the time of codig, programmer will be havig complexity so it will help him/her to keep limit o the complexity of the code is to be geerated. This measure is computatioally simple ad will aid the developer ad practitioer i evaluatig the software complexity i early phases which otherwise is very tedious to carry out as a itegral part of the software plaig. Sice etire approach is based o SRS documet so it is for sure that a SRS must have all the characteristics, cotet ad fuctioality to make this estimatio precise ad perfect. This measure is simple to uderstad, easy to calculate ad less time cosumig i.e. it satisfy most feature of a good measure. REFERENCES [1] Weyuker E., Evaluatig software complexity measures. IEEE Trasactios o Software Egieerig, 1988, 14 (9): [2] Halstead, M.H., Elemets of Software Sciece, Elsevier North, New York, [3] Mc Cabe, T.H., A Complexity measure, IEEE Trasactios o Software Egieerig, SE-2,6, pp , [4] Halstead M.H, "Elemet of Software Sciece", Amsterdam: Elsevier, [5] T.Klemola ad J.Rillig, "A Cogitive complexity metric based o Category learig" Proceedigs of EEEE (ICCI'03), pp , [6] Elaie J. Weyuker, Evaluatig Software Complexity Measures, IEEE Trasactios o software egieerig, Vol. 14, No. 9, September [7]IEEE Computer Society: IEEE Recommeded Practice for Software Requiremet Specificatios, New York,

6 [8] Wag. Y ad Shao,J., O Cogitive iformatics, 1 st IEEE Iteratioal Coferece o Cogitive Iformatics, Pages 34-42, August [9] Wag, Y. ad Shao, J., Measuremet of the Cogitive Fuctioal Complexity of Software, 3 rd IEEE Iteratioal Coferece o Cogitive Iformatics (ICCI 04). [10]Y.Wag. ad J. Shao. "Measuremet of the Cogitive Fuctioal Complexity of Software," Cogitive weights", Proceedigs of IEEE (ICCI'03) , [11] Wag.Y ad Shao J. (2003). A ew measure of software complexity based o cogiitive weights, Ca.J.Elect. Comput. Eg., 28, 2, [12]D.S.Kushwaha ad A.XK Misra,"Robustess Aalysis of Cogitive Iformatio Complexity\Measure usig Weyuker Properties," ACM SIGSOFT SEN 31, 1, [13]Aurag Bhatagar,Nikhar Tak ad Shweta Shukla, A literature survey o various software complexity measures, IJASCSE Volume 1 Issue