Analysis of software metrics using fuzzy logic and genetic algorithms

Transcription

1 Free University of Bolzano Faculty of Computer Science Applied Computer Science Analysis of software metrics using fuzzy logic and genetic algorithms Student: Mussner Armin Matriculation number: 1129 Supervisor: Prof. Ing Succi Giancarlo Academic year: 2003/2004

2 Table of contents TABLE OF CONTENT...2 TABLE OF FIGURES ABSTRACT ACKNOWLEDGMENTS INTRODUCTION STAGE AT THE ENTITY-AG The initial situation Motivation of the introduction of C# The level architecture Layout Business Component Data Access Access The database of C#Timekeeper The Timekeeper application Development of the application The Timekeeper module The organisation module The Projects module The Timeplaning Module The Boards module Ideas and opinions on the Timekeeper PROM Used metrics: THE FUZZY LOGIC OR and AND neurons The architecture of fuzzy logic network Genetic Algorithms (GA) Input-Output interfaces of fuzzy logic network The model on a practical point of view Problems in the metrics collected by PROM

3 6.5 The statistical analysis The genetic algorithm in the praxis The experiments with PROM and the GA CONCLUSIONS BIBLIOGRAPHY...30 Table of figures Figure 4-1 Level structure... 9 Figure 4-2 Use Case of the Timekeeper module Figure 4-3Use Case of the organisation module Figure 4-4Use Case of the projects module Figure 4-5Use Case of the Timeplaning module Figure 4-6Use Case of the Boards module Figure 6-1OR/AND neurons architecture Figure 6-2 module structure of the OR/AND neurons Figure 6-3Examples of refinement of the concept (f) developed at some level of the network: (a) generalization with the aid of additional variables (d), and (b) its specialization Figure 6-4A schematic view of a chromosome consisting structural (integer coded) and parametric (real number coded) part of the network Figure 6-5General schematics of interfaces of fuzzy logic networks: Figure 6-6 Distribution of the lines of code Figure 6-7 Input function of the lines of code

4 Valguna persones se semieia de gran lëures, de autri stà descedei y i fej - Anonymous - 4

5 1 Abstract This thesis was supposed to be written completely in Ladin to demonstrate the use of the language in writing technical papers. Unfortunately it was not possible to hand in the thesis in Ladin. The whole thesis will be translated in English and the Ladin version will be attached to the English version in order to demonstrate the huge work behind this thesis. The first part of the thesis explains the work done during the stage period at the Entity AG, a young company situated in Bolzano. Our goal was to develop a personal management tool for the internal usage of the company, called C#Timekeeper. The whole project was structured in modules in order to have a better scalability and reusability for the future. The scope of the stage was not only to develop an application but to test new technologies which will possibly be applied in further projects. One of the new technologies, we used was the new programming language of Microsoft called C# in the Microsoft Visual Studio.NET environment. The advantage of this language is the perfect compatibility with Microsoft Windows and its object oriented structure. The majority of the customers of the company work on an Oracle database and access it with Microsoft Windows clients. It was of crucial importance for the company to have a fast connection between the clients and the database. For this reason we adopted a layer structure which should improve the connection to the database. One of the goals of the project was to collect data about the working skills and habits of the programmers, which is an important information for the company. The company can se this data to allocate the resources and to forecast the effort on future projects. This process can be done more accurately and precisely with PROM, that collects the effort and the metrics of the classes automatically during the working period of the developer. To analyze this data we used a mathematical model based on Fuzzy sets and genetic algorithms developed at the University of Alberta in Canada. This model allowed us to have a better idea of the data and maybe in future we will be able to forecast in a better way the effort on a project based on the software metrics collected automatically by PROM (Professional Metrics). The mathematic model is still in a developing phase, so our main goal is to understand the basics of the model and to get an idea how to apply this model to the metrics. 5

6 2 Acknowledgments First of all I would like to thank Prof. Succi that has give me the possibility to write this thesis in Ladin and afterward in English and for the experiences I had the fortune to do at University of Alberta in Canada. Special thanks to Prof. Witold Pedrycz of the University of Alberta for the attention he given to this experiments. Thanks to Sara Mani and Federica Cumer for all the questions they answered me and for the psychological support that they had given to me. 6

7 3 Introduction During the stage period in the company called Entity-AG we developed a personal management tool called C#Timekeeper. One of the main tasks of this application was to collect the working hours of the developers during the development phase. After the realization of the project we saw that one of the main problems of the application was the retrieving method of the data of the system. The developer has to insert the information in the program. Erroneous data can be inserted during this task. It would be useful to have a program which collects automatically the information about the time spent on a project. Once we have reliable information about a software projects we, had to find a method which allows us to analyse the data and to retrieve useful information which will help us to predict the effort in future projects. 4 Stage at the Entity-AG The Entity-AG is a young company. Its business is mainly focused in governmental solutions for the province. In most of the cases the province institutions works with large database which has to be accessed in a fastest way. The company is open to test new technologies that can be applied in the development of software projects. One of these new technologies was the new programming language from Microsoft called C#. The IDE(Integrated Development Environment) we were supposed to use was the Visual Studio 2003 from Microsoft. For the connection to the database we used a Data Adapter from Oracle which allows a faster connection to an Oracle database than a Microsoft Data Adapter. 4.1 The initial situation The scope of the stage was not only to develop an application but also to try new technologies and new software architectures which can be applied in future projects. The C#Timekeeper is based on an existing application, developed by the Entity with an Oracle development tool. The first Timekeeper was been gradually developed by different programmers and all the time new functionalities were added. At the end the program was so complicated that the company decided to develop a new application using C#. This programming language adopts components familiar to windows users. The Oracle developing tool is mainly developed to build a graphical interface that deals with an Oracle database. This kind of developing tool has restricted functions and is not any more competitive in the today market. For this reason the Entity-AG is trying to move from the Oracle development tool to the programming language C#. An important point for the company was a fast connection to the large databases. To have a fast connection to the database we did not used a provider from Microsoft, instead we used the Data Adapter from Oracle which were supposed to be two times faster and more reliable. 4.2 Motivation of the introduction of C# C# is a young programming language introduced by Microsoft, based on an object oriented structure. We can denote the similarities with the programming language of Sun Microsystems called JAVA. A large part of the customers are Windows users, so it is important to develop a fully compatible application. The framework which allows us to develop Windows compatible application is the.net environment developed by Microsoft. In this framework the developer can use more programming languages for different classes. 7

8 For instance one class can be written in C#, another class can be written in Visual Basic and a third one can be written in C++. Using C# for our project we have a substantial advantage in the development of the graphical user interfaces. All the graphical controls available in the Visual Studio are the standard controls used in the Windows environment. This is important for a user friendly application because the user is immediately comfortable with the application. C# is not a compiled language, it is an interpreted language which is translated in an intermediate language called MSIL (Microsoft Intermediate Language) and then interpreted and executed by the CLR (Common Language Runtime). Another technology that we adopted in our project was the usage of data in the database in an offline mode. Normally an application remains connected to the database for the time necessary to manipulate the data. The connection to the database will be closed when the client does not need any more a connection to the database. The.NET approach to the database connection is to transfer the needed data on the client machine. All the data will be saved in a DataSet with the correspondent table structure of the database. Once the data is modified, added or deleted the DataSet will be joined with the original database and all the needed data modifications will be taken. Using this system we can save a lot of connections to the database. The user does not need to be connected all the time to the database to see the information, he just transfers a copy of the needed information in the local dataset, then the connection to the database will close. When the user has finished to edit the data, the connection to the database will be opened and the modifications in the dataset will be joined with the data in the database. 4.3 The level architecture For a better scalability and reusability of the application we used a layer structure. The use of a layered structure gives us the possibility to substitute different layers without changing all the application structure. For example if in the future the company decides to change the database system, we do not need to change the whole application, but only the layer involved in the connection to the database. Using a layer structure brings advantages in the search of errors in the code because all the layers are separated so the error can be isolated to the single level. In our case we used a layer structure commonly used in the.net framework, which consists in dividing the program structure in 4 layers: Layout, Business Component, Data Access, Services. 8

9 Figure 4-1 Level structure Layout This level implements the graphical part of the application. It has the function to communicate and to interact with the end user. The data passed from the levels below are modified in order to be shown in a comprehensible way to the user which uses the application. On the customer side this layer is the most important because it is the part that the customer can see. All the actions taken from the user will be transformed so that it is possible to send the information to the levels below Business Component To make it possible for the application to work with the database, we have to transform the data coming from the Layout layer in commands. The most used commands in the application were the insert, update, delete and view command. In our case we made a general class which contained all the most used and the most important commands. For more specific commands we made different subclasses with more attributes. All the tables in the database a subclass of the general class was generated which contained the commands. In this commands we decided which data we want to retrieve and in which order they should be loaded. At the moment that we get all the information we need for the command, it is passed to the lower level. From the levels below we get the information in form of an SQL table which has to be modified to be sent in the next layer Data Access In order to communicate with the database we have to translate the commands coming from the upper level, in SQL commands SQL is a standard language used in communications with databases. The commands generated in this layer are commands useful for every kind of database. They are not restricted to a specific kind of database systems. From the level below we get all the data from the database. In case of an update or an insert in the database we get the number of rows affected in the database. 9

10 4.3.4 Access This is the final layer before the database, it is important for the right communication between the application and the database. This level is configured to make the communication of the data as fast as possible. Every kind of database has a specific driver which should be used properly for a reliable connection. In our case we did not used the Microsoft driver, instead we used the driver developed from Oracle which should improve the velocity of the connection between database and application. 4.4 The database of C#Timekeeper The primary task of the application is to deal with a database, for this reason we thought that it would be a good idea to start the project with the design of the database. Based on the old version of the TimeKeeper database, we improved the access to the data, divided some tables, joined others and added some new tables. In the design phase of the database we worked keeping in mind that the new database has to contain the data of the old database as well. For this reason we tried to design the tables similar to the old ones. A new important feature inserted in the database was a system of hierarchy for the employees of the company. This allowed that some data can be restricted to some employees. Using the hierarchy system it is possible to personalize the application for every kind of user. 4.5 The Timekeeper application The application developed from the Entity-AG was originally thought to keep trace of the working hours spent on the application. The company is certified ISO so it is of important to trace every single step done by the developers. The old version of the Timekeeper was developed incrementally and gradually. At the end the application was filled with bugs and missing functionalities which were difficult to add to the existing application without an extensive revision of the whole application. For the database we used an Oracle database as it was in the old version. As programming languages we used the new Microsoft language called C# with Visual Studio The project has been realised by tree students, this imposed us to use a versioning tool called Visual Source Safe which helped us to integrate the classes written by us in a single project. It is also possible to follow every single modification made by the developers in the classes. It also blocks the class so that it is not possible for others developers to work on the same class. Because of the large amount of data that we need to consult and to edit, it is of crucial importance for the company to have a connection with the database which is as fast as possible. Our main goal was to develop this application and to test the connection with the database using a provider built by the Oracle. Moreover we had to use a layered structure to improve the performances of the application. As we continued with the development of the project we noticed that the use of the business level imposed by the company was not the best one. We missed some important features which were not implemented in this model. In the development phase of the application we kept in mind that probably the application will be translated in other languages. This will be done using the internationalization function of the.net framework, which allows the translation of an application without touching the code. The application was not only projected to be applied in one company, but it was possible to have developers who work in different companies at the same time. The Entity-Ag uses to share their developers with the developers of the partner company called EOS. For a right implementation of the application we had to understand how the projects are structured in the company, e. g. projects, modules and sub modules. This sub division will be done by the manger which has also the duty of assigning to every developer the respective modules and sub modules of the project. 10

11 It was also possible that the developer work was divided in more projects. The application does not trace only the working hours of the developer but also his leisure time and all the meetings involved in the project. In theory at the end of the working day the developer has the duty to insert in the application the activity done on which part of the project. It is important for the company to have this information so that it is possible to reconstruct the effort that each single module has taken and how much each single developer has worked on it. It is also possible to understand if the planed budget was sufficient or if it was not appropriated. This information can be useful in a future for a forecast on the effort on other projects, which is for sure not a simple task due to the huge differences between one project and another. 4.6 Development of the application For the design of the application we used an agile methodology called XP (Extreme programming) which main goal is the continuous interaction with the customer in order to satisfy him as more as possible. The first step in the XP methodology is to collect as more information as possible about the application and to summarize them in a graphical way. This diagram is called Use Cases and it shows all the possible actions that the user can do with the application. In the case of the Timekeeper we decided to divide the Use Case diagram in many parts. The logical split was to have one Use Case for each module. it was also useful to have a clearer view of the whole project. 11

12 4.6.1 The Timekeeper module This is the principal module of the application and it collects the information about the working hours on the various parts of the projects. It has also other functions like storing information like expenses regarding the project and eventual trip expenses. Figure 4-2 Use Case of the Timekeeper module In this Use Case diagram we can see all the actions that regarding this module. The most important actions are: Change the day, in order to enter the information about the working time in days different from the current. Change organisation, the employee can change the organisation if he is working on a project regarding another company. Insert the information regarding what kind of action the employee has done on the different modules. (insert records) Insert or modify the expenses and trips regarding the project. (manage expenses) 12

13 4.6.2 The organisation module Figure 4-3Use Case of the organisation module This module can only be used from a manager who has the rights to edit the data regarding an organisation. The information bound to a company are the free days of the company, how the data about the projects will be collected (hour-to-hour, daily or weekly). There is the possibility to assign the employees to the different organisations. The program changes it appearance for every user depending on the project were he is involved. 13

14 4.6.3 The Projects module Figure 4-4Use Case of the projects module This module has to maintain and to organise all the information regarding the projects and its modules. Every time a developer inserts a record about the work he has done, he has to specify which kind of activity he did and on which module or sub module he worked. The managers can check every time the status of the projects, who works on which part and for how long. All the documents regarding the project are stored in this section as well, so that the manager has the possibility to see the offers made to the customer and eventually the bills regarding the project. The manager has the possibility to insert or delete parts of the project, the other way around the developer can only consult the where he is involved and insert how much time he is going to take for the project. 14

15 4.6.4 The Timeplaning Module Figure 4-5Use Case of the Timeplaning module For a good organisation of the project the manager can plan the working activities for the affiliated developers. He can assign the modules to different developers, giving them a maximum time for the development phase. The manager can also choose to plan the developing activities on a daily, weekly or monthly base. Once he has inserted the information of one day he can copy the information to different days, without creating new record for all the days. 15

16 4.6.5 The Boards module Figure 4-6Use Case of the Boards module In order to have a good plan on the project it is important to meet with the development group so that it is possible to discuss eventual problems and further steps. This will be done by the module regarding the meetings. The manager can fix a date for the meeting and who has to attend to the meeting. The developer who has to attend this meeting will get an entry in his agenda. 4.7 Ideas and opinions on the Timekeeper The Timekeeper keeps merely trace of the time spent on the different modules of the project, it does not consider the difficulties and how large the different modules of the modules are. In order to have better idea of the effort spent in a class it should be useful to know the effort and the characteristic of the class. To measure how difficult it is to write a class is difficult task, because there are a lot of variables to consider. The data collected by the Timekeeper is only of time, we have no idea about the difficulties encountered in developing the class. The Timekeeper is useful to trace the working hours for an ISO certification where every step in the development phase has to be traced. The collected data can only partially be used for a forecast on the effort for future projects. In an application like this it may happen that erroneous data will be inserted, because the developer forgets to insert the data or it does not consider an important task. To improve the correctness of the data we should avoid the relations with the developer. It would be useful to have a program which collects the data automatically during the working time of the developer. This would decrease significantly the amount of erroneous data. Moreover the developer does not loose any time in inserting the data about his work, spending it in more useful tasks. The application should not only collect the effort spent on a class but metrics of the code as well. This issue was analysed by the Free University of Bolzano where they developed a tool called PROM (Professional Metrics) which should collect automatically the effort spent in developing. 16

17 5 PROM This is a project of the Free University of Bolzano with the aim to improve the software quality and the software production. To achieve this goal it is essential to understand how software is being made and in a second step understand the used methodologies. The set of tools called PROM can be divided into two major categories: the database part and the plug-ins part. The database part has the task to store all the collected information and to generate the software metrics for the files. In this way it is possible to have a certain measure about the size and the difficulties encountered in writing code. The goal of PROM Trace is to collect the time needed to write a specific class. If it is necessary to have a more granular information about the effort spent (e.g. time needed to write a single method) it is necessary to use a specific plug-in for the development environment. PROM Trace is a program running in background and the user does not notice the any presence of the application (the only visible part is an icon in the system tray). For every program which starts, a record is stored in the database with the name of the program, how long the program is used and who used it. Another information that is considered by PROM Trace is the group that works on a project. Sometimes it is interesting to compare the usage of two applications in order to perform the same task. Another study is to understand the role of Google when developing applications. It is also useful to understand the problems occurring during the course of a project. The manager can divide the workload in a better way between the employees or the working groups when he knows the effort currently spent in the different tasks. The most important task during the project is writing the code, for this reason it is important to monitor this activity. On this basis the Eclipse plug-in for the JAVA programming language was written. In a second moment plug-ins for the language C++ and C# will be developed. The task of this plug-in is to monitor the way the single program is written. In the database the time needed to write the single class or single method is written in order to understand difficulties encountered by the programmer and also to understand the most difficult parts of the work done. In order to calculate software metrics, the source code has to be stored on a CVS server on which from time to time all files are parsed and the metrics will be calculated. From this calculated metrics 8 are used to understand the size and the complexity of the written code. 5.1 Used metrics: Lines of code : this metric was developed to understand the size of the code. This metrics is one of the most important in order to understand the size of the project since it is calculated for every class and for every single method. McCabe s Cyclomatic Complexity is a metric that considers the complexity of the code. This metric indicates the number of possible linear paths to traverse a single method. The metric is also useful as an estimator of the number of defects contained. The more complex a method is, the more probable it is that this method contains defects. Number of methods per class : This metric is calculated for every written class. Some authors promote the idea that it is a good programming style to limit the lines per class to 20. To accomplish this, a long method has to be split up into two or more parts. This reduces the lines per method but increases the number of methods per class and so the overall complexity of the class. 17

18 Depth of inheritance (DOI) is the length of the inheritance path from the base class to the measured class. In the case of PROM this is calculated for every class. The DOI represents the depth that a class has within the inheritance tree of the project. A high value of DOI means that many methods are inherited by the analyzed class, that the complexity of the class rises as DOI increases and therefore the maintainability of that class decreases. Number of children measures the number of classes that extend the considered class. If a class has many classes that inherit from that class, it means that it is an important class that has to be monitored since changes in that class have repercussions in all the underlying classes. Changing that class means to implicitly change all the connected classes which can have unforeseen results. Coupling Between Objects (CBO) is the number of classes that make use of another class. The higher the dependency that one class has with other classes the lower the probability that it can be reused for different purposes. The higher the CBO value, the more difficult it is to separate the classes into reusable modules so if it is a goal to reuse parts of the developed code in other projects it would be good to keep the CBO value low. Response for a class (RFC) measures the number of methods that are called in order to execute a method. If many methods are called in order to computer the result of a called method, it is more complicated to understand what the single method is doing, debug becomes harder and the containing class becomes more difficult to read. Lack of Cohesion in Methods (LCOM). Chidamber and Kemerer define Lack of Cohesion in Methods as the number of pairs of methods in a class that don't have at least one field in common minus the number of pairs of methods in the class that do share at least one field. When this value is negative, the metric value is set to zero. If LCOM is high, the class should be split up into two or more separate classes. The information collected by the parser are also saved in the PROM database and in a second moment integrated with the data collected by PROM Trace in order to understand the effort to develop the single class or method. To know the effort of the single class or method helps to have a better view of a program and its parts and is useful to understand what part needed more time in other words had a higher cost and what part did not. It is clear that PROM can not collect the complete effort spent in order to perform the single tasks, but the most part of the effort can be now collected automatically, without user intervention. If the developer reads a book or a manual this can not be traced by the program and has to be written by hand by the developer. Fortunately the part of time spent with these activities is becoming less important since it is possible to obtain the needed information from internet to. For the other rare cases in which it is needed to collect this information it is necessary to enter it by hand. All this data is collected for a good reason: to analyze and to be able to understand if there is a relation between the collected metrics and the effort spent. To analyze this data many different methods exist. One of these methods is to use Fuzzy Logic and Genetic Algorithms. In detail, it is possible to use AND and OR neurons within the Fuzzy Logic domain to better understand the different factors influencing the total effort spent for a project. 18

19 6 The fuzzy logic The fuzzy logic provides a simple way to arrive at a conclusion where we have missing, ambiguous or missing input data. The way fuzzy logic comes to a result can be compared with the way a person will take a decision, only much faster. Instead of trying to solve a problem mathematically the fuzzy logic relays on simple logic rules like: if X and Y happen then do Z (IF X AND Y THEN Z). One of the advantages of this logic is that it is robust against erroneous data collected by humans or machines. It is possible to have many sources as input but only one output result. The input and output functions can be selected by the person, it is not automatically. This makes the model very flexible to be used in a variety of fields. In order to manage at best the variables we do not use numeric values, instead we make sets and call them with common words which gives them a meaning like: large, medium and small. The same can also be done with the output which will look like: good, satisfied and bad. Doing like this it is possible to create logical rules, which looks more like a natural language without making use of mathematical models. There is only one function which can be combined with every parameter. This function gives to every data a weighted value raging from 0 and 1. The function can be open on the right part, that means that the high function goes to infinite OR and AND neurons The network that we are going to analyse is a network composed of OR and AND neurons. The structure of the network is composed of logical expressions and Boolean operators. The network construction has been realised using a genetic optimization. In order to simplify the structure of the network the model has the possibility to prune some parts of the network structure. The fuzzy neurons are a really interesting structure that can be implemented with the qualities of a genetic algorithm. The most important quality of a network of neurons is the ability to learn and improve the reliability with the training of the network. The network is composed of several AND and OR fuzzy logic neurons organised in a two-level architecture. For a an OR neuron we mean a fuzzy neuron that realizes a logic mapping from 0,1 to [0, 1] in the following format: [ ] n y = OR( x; w) = n S ( x tw ) i= 1 i i where x i denotes i-th input and w i stands for the associated weight (connection) assuming values in the unit interval. The aggregation operations are implemented using s- and t-norms. This expression can be seen us a logic expression with a collection of weights (connections) y=(x1 and w1) or (x2 and w2) or... or ( xn and w n ). To make it more understandable we can use a shorthand notation which looks like this: y = OR(x; w) where x and w denote the input connections vectors of data x=[x 1,x 2,...x n ], w=[w 1,w 2,...w n ] The same reasoning works for the AND neuron: y = AND( x; w) = T= i n 1 ( x sw i i ) 19

20 This formula is similar to the previous construct only that it is in a reversed mode. The same way us in the OR neuron the simplified formula for the AND neuron is y = AND(x; w) The AND/OR neurons will then be arranged in a configuration like the one shown in the figure bellow: Figure 6-1OR/AND neurons architecture Given this structure of OR/AND, we can say that the final formula is: z = AND( x; ); z = OR( x; ); y = OR( z; w); 1 w T = v v 1 2 y T 2 u where y z = z z 1 2 The connections between the neurons help us to tune the input and output characteristics of the data. This is an important point on the learning phase of the network. The s-norm and t-norm is another mechanism that can be used to tune at best the capacities of the network for the kind of data that it has to analyse. We have to denote a difference between the use of the min - max tandem versus other combinations of t- and s-norms whose usage usually gives rise to significantly smoother input-output dependencies. An important advantage of the OR/AND neurons resides in the high interpretability of the network. Even though the neuron itself may look a bit complicated, its underlying logic expression becomes straightforward and readable. The two OR/AND neurons of the first level realize two generic logical functions of OR and AND operations. The result of the two first neurons will then be combined with an OR neuron this aggregation helps to establish an interesting combination of the overall structure. Note that if v 1 = 1 and v 2 = 0 we end up with a pure and aggregation. The combination of v 1 = 0 and v 2 = 1 leads to the pure or-wise aggregation of the inputs. A whole spectrum of situations in-between the pure and and or aggregations is captured by the intermediate values of the connections of the OR neuron in the output layer. The OR neuron aggregates inputs or-wise with the weights (connections) that are essential to the modelling contribution of individual inputs to the output. The higher the value of the connection, w i the more significant the corresponding input is. In this sense, different inputs affect the output to a different degree and this feature is of profound relevance for learning purposes. The situation is opposite in case of the AND neuron: here higher values of the connections hide the inputs and therefore the value with the highest relevance of the input happens is the input that comes with the connection equal to zero. 20

21 6.1.2 The architecture of fuzzy logic network The most important part of the network are the OR/AND neurons as the computing nodes of the architecture. The nodes are arranged in a cascade structure like the one shown in the figure below: Figure 6-2 module structure of the OR/AND neurons With this structure it is possible to combine input data with the output data of stepwise. Moreover we can see the output of the first OR/AND block us f 1 = OR / AND( x; w1 ) where w 1 means the connection of the structure of this neuron. The output of the second OR/AND neuron is calculated after the first neuron and it involves also the inputs x and f 1 of the first neuron. The output of the second neuron will then be: f T [ x; f ] ; ) = OR / AND( w where [ x; f ] T 1 forms the vector of inputs in this neuron. The number of inputs to a neuron is a good predictor of how complicated a neuron will be. The connections between the neurons represent a balance in the logical expressions or/and in the calculations. To better understand the function of this network we can look at the figure below: Figure 6-3Examples of refinement of the concept (f) developed at some level of the network: (a) generalization with the aid of additional variables (d), and (b) its specialization 21

22 The only working knowledge we need at this point comes in the form of the boundary conditions of t- and s-norms. Moreover we know that a connection with a value equal to null in an OR neuron will be removed because it is useless. In the same way a connection which goes to an AND neuron with a value of 1 will be deleted. Following these two simple interpretation rules, we arrive at the logic expression that could be read out directly from the network: y = OR( AND( x1; x3), OR( x2; x4 )) = ( x1 x3) ( x2 x3 ) 6.2 Genetic Algorithms (GA) The development of the proposed network involves two main categories of design decisions such as: The number of variables needed for the model can be reduced significantly without any visible deterioration of the approximation abilities of the network. How large and deep the network can be chosen at the beginning of the modelling process. The selection of a subset of the variables is a combinatorial problem and here the role of genetic optimization becomes essential. The optimization of the values of the parameters of the connections of the neurons could be a domain of gradient-based learning. The use of GA here is still advantageous: the structure could exhibit significant depth that significantly obstructs the efficiency of the method where a back-propagation of error has to be realized throughout the entire structure of the network. The larger the depth of the structure, the more difficulties arise and the lower the efficiency of the ensuing learning. Having the optimization task in mind, the chromosome consists of two parts. The first part is binary coded which concerns the indexes of the variables. The parameters of the neurons (real numbers) are coded as floating numbers. This arrangement of the chromosome is quite in line with the phenotype-genotype transformations. Figure 6-4A schematic view of a chromosome consisting structural (integer coded) and parametric (real number coded) part of the network The most essential algorithmic components of the GA setting concern crossover and mutation operators. In the subsequent experiments those are chosen to be a two-point crossover and a uniform mutation operator. The fitness function is formed on a basis of the performance index of the network. Given some training dataset coming in the standard format of input-output pairs, that is (x(k), target(k)), k =1,2,...n the sum of squared errors: Q = n k = 1 ( x( k) t arg et( k)) 22 T ( x( k) t arg et( k)) Is a commonly used measure for the fitness of the network. The GA can use Q and minimize its values or equivalently form a certain fitness function whose values are maximized. In order to interpret at best the network we can say that we can take the network in his optimized form to achieve a logical expression

23 There is a further way to simplify even more the logical expression of the network output is the possibility of pruning the connection of less importance. This operation is done manually based on the values of connections between the nodes. On the part of the OR neuron we can say that the higher the value of the connection the more important the connection for the network. To prune connection which goes to the OR neuron with a value of zero does not influence the network at all. To make this operation we have a limit called λ with values defined between w λ w ifw λ = 0 otherwise This formula returns an original value of the connection (w) if it exceeds or is equal to λ. Otherwise if it is quite weak, we prune the connection and return a zero value. The higher the threshold, the more connections become eliminated from the original network. The operation reflects our previous observation that weaker connections relate to the variables that could be eliminated. The pruning of the connection on the part of the AND neuron is: w µ w ifw µ 1 otherwise In this formula we use a certain different threshold, say µ. Now the connections whose values are above the threshold µ are pruned. By setting their values to 1 (that corresponds to a complete masking effect) we eliminate the corresponding input. The lower the value of the threshold, the more radical the resulting pruning of the AND neurons. The combination of these two thresholds (λ, µ) serves as a general pruning mechanism. The choice of their values becomes a compromise between the reduced accuracy of the network and its increasing interpretability. These two characteristics are in conflict. Possible optimization is very much user-oriented: we may wish move with further reductions of the network given its interpretation benefits from the reduced form of the model and accept somewhat higher values of the approximation error Input-Output interfaces of fuzzy logic network In order to communicate with the network we need to interpret the physical values of the real world in a manner that the network canndle them. The easiest way is to establish fuzzy sets in the input and in the output. These fuzzy sets should represent at best the real values which can be grouped in sets like good, median and large. Given a numeric input z R and a collection of fuzzy sets defined in this space, say { A1, A2,..., An} the result of the transformation is a vector of membership grades x = [ A1 ( z)... An ( z) ]. When all the data has been assigned to its fuzzy set we can calculate the result basing on the fuzzy sets instead of the numeric values. In the graphical representation below we can see the transformation of the values. 23

24 Figure 6-5General schematics of interfaces of fuzzy logic networks: 6.3 The model on a practical point of view The first task was to search the PROM database for reliable data which we can apply to the fuzzy model. At the moment there are no tools which are able to combine the effort stored in the PROM database with the data regarding the metrics of the single class. This procedure was done manually, searching the PROM Trace table for the effort and the Eclipse plug-in table with the metrics for the same class. After searching the database we found 40 classes where we found all the metrics and the correspondent effort. Before applying the data to the fuzzy model we made a statistical analysis of the data. From the statistical analysis we have seen the distribution for every single metric. 6.4 Problems in the metrics collected by PROM One of the first problems we encountered in the analysis of the data was that we had many entries in the database for the same class. This happens when the class is written in different times so that we have many values for the same class. In these cases we added the effort of the different entries. For the metrics it was not possible to add the data because this will bring to fault information. For example if we have a class with 100 lines of code and in a second moment we decide to delete some of them. What happens is that we will see in the database a class with a high effort but only a few lines of code. To partly avoid this behaviour we decided to apply the mean of all the metrics. This will give a more correct representation of the size and difficulties of the class. A problem arises when the developer only modifies the class without adding or deleting some lines of code, then the mean is not any more a reliable operation. To make the measure more precise it would be better to analyse the class stepwise looking at how much time the class was modified and how. In our analysis we did not paid attention to how many times a class was modified because it was not possible to enter this data in the model. The classes we chose were taken randomly without taking account of the developer who wrote them or to which project they belong. At the moment of the analysis we had not enough classes to do such a separation. It would be interesting to apply the model to the classes made by one developer or to classes belonging to the same project in order to have more information about the capabilities of the developer and the effort spent on a project. Often it would have been useful to have the classes to check the code to better understand how PROM works and if there are errors in the collection of the metrics. Another habit of the developer which can bring to fault data is the action of copying and pasting the lines of code from class to class. If most of the code of a class is copied it could happen that we have a class with a low effort but high values in all the metrics. More or less the same happens when we rename a class then an entry appears in the database with no effort at all. The old class will be deleted and so all the data rewarding this class is loosed. 24

25 For detailed information it would be useful to know when these actions happen in order to make a more precise analysis. The same problem arises for the classes and methods which are auto generated from the development environment. This methods and classes are normally very large but have a low effort this would bring to misunderstanding information for the fuzzy model. It would be useful to know in advance which methods and classes are auto generated because often this makes the largest part of a project. 6.5 The statistical analysis First of all we calculated the distribution of data so that it was possible to have a better idea how the data will look like. For every single metric we calculated the distribution and the correlation. Whit the help of the distribution we can have a better overview of the bounds of the classes and where we can find the most classes. This information helped as to subdivide the data and finally to make the subsets: Lines of code Effort LOC Series1 Figure 6-6 Distribution of the lines of code The next step was to calculate the correlation between the effort and the single metrics with the help of a correlation table. In the correlation table we can see the correlation between a metric with all the other metrics. Of course the correlation with the higher importance is the one between the single metrics and the effort. CBO DoI LCM LOC NoC NoM RfC Effort CBO 1.00 DoI LCM LOC NoC NoM RfC Effort Table 1 Correlation between metrics and effort CBO = Coupling Between Objects DoI =. Depth of Inheritance LCM = Lack of Cohesion in Methods LOC = Lines of Code NoC = Number of Children NoM = Number of Methods RfC = Response for a class 25

26 In this correlation table we omitted two metrics (McCabe's Cyclomatic Complexity and the Halstead Volume). This two metrics are not collected globally for the whole class but for every single method. As expected the correlation between the lines of code an effort is the highest one. All the other correlations are not especially strong but this should not necessarily influence the result of the model. It could be that the neurological network is able to find some relation that the correlation table does not reveal. The correlation helps us only to understand how much a value is increasing or decreasing respect to another value. Another important point that we noticed is that the two metrics Depth of Inheritance and Number of children. This two metrics do not change much in the time and the range is low as well. It means that this metrics do not give enough information. In the second table we took also the two missing metrics. To use this two metrics we calculated the mean value of this metrics for the class so that we can add this two metrics to the correlation table: CBO DoI HV LCM LOC MCC NoC NoM RfC Effort CBO 1.00 DoI HV LCM LOC MCC NoC NoM RfC Effort Table 2 Correlation between metrics and effort with MCC and HV CBO = Coupling Between Objects DoI =. Depth of Inheritance HV = Halstead Volume LCM = Lack of Cohesion in Methods LOC = Lines of Code MCC = McCabe's Cyclomatic Complexity NoC = Number of Children NoM = Number of Methods RfC = Response for a class From this table we can see that the correlation between the McCabe's Cyclomatic Complexity and the effort is the second highest. After the experiments with the model it would be interesting to see if the metrics with the higher correlation are also the ones with the higher importance in the model. 6.6 The genetic algorithm in the praxis As mathematical model we used an application developed at the University of Alberta in Canada which were at the time in a beta phase. This application reads the data from a text file where it is also specified how many datasets (classes) and how many attributes (metrics) the file contains. After having imported the data in the application we had to choose how many functions we would like to have in input and in output. Then we have to set the number of generations and the population of the genetic algorithm. The higher the number of individuals in the population and the number of generations the more time the model had to make the calculation. After the calculation, the model shows a graphical representation of the relationship between the original values and the values calculated by the model. In another graphical representation we 26