Transformations of Erlang programs based on complexity metrics

Transformations of Erlang programs based on complexity metrics Thesises of the Doctoral Dissertation 2013 Roland Király http://aries.ektf.hu/~serial/kiralyroland/ kiraly.roland@aries.ektf.hu Advisor: Dr. Horváth Zoltán Eötvös Loránd University, Faculty of Informatics H-1117 Budapest, Pázmány Péter sétány 1/C. PhD School of Computer Science Title of the PhD Program: Basics and methodology of informatics Leader of the PHD School: Dr. Benczúr András This research was supported by the European Union and the State of Hungary, co-financed by the European Social Fund in the framework of TÁMOP 4.2.4. A/2-11-1-2012-0001 National Excellence Program.

2 Introduction As the size and complexity of programs increase, the development (and the resource cost of development) has an ever increasing part consisting of testing, solving the difficulties arising during testing, and proving that the modification of source code does not change the program semantically. The cost (be it in work hour, human resources, etc.) of modifications in code does not solely depend on its amount, but its complexity also plays a significant role in it. Measuring complexity makes it possible to estimate testing and maintenance costs, both of which are an important factor of code development. The various methods of analyzing source code measure such properties, that help us get an idea about its structure, characteristics, and complexity. Based on the results obtained from such analysis we can give estimates about the cost of testing, developing, or modifying the code. The measure of software complexity can grade the programming style, usability, and the expected developmental costs. Comparably the relationship between various parts of code, exploration of the relationship between these measures and their interaction can give a more precise picture of the code forming the subject matter of the measurement. Based on this statement, in the theses we build a model, that we can use to examine the software measures, and the effect of code transformations through which automatic, source code quality improving transformations can be applied. Objectives Since the start of the research my goals were the following: 1. To find methods which make it possible to measure the complexity of, and can apply agile and simple transformations to large programs used even in industrial environments written in Erlang [32, 40], a language that supports the paradigms of shared programming, and behavioral patterns 2. To create a structured query language and its filters that are capable of measure complexity measures, with the help of which measuring Erlang source code complexity becomes easier and faster 3. To construct a complexity based analyzing algorithm, with the help of which during any phase of coding the change in complexity measures can indicate programming errors or inconsistencies, therefore the code development can be limited to pre-defined, clearly stated confines

3 4. To extend this query language with elements to implement automatic code transformations (transformational meta language), as well as creating an algorithm to run scripts written in this language, that provides the ability to automatically transform source code based on complexity measure. Antecedent of the choice of subject I started my research with the research team operating at the Faculty of Informatics at Eötvös Lóránd University that deals with refactoring Erlang programs, where there were plenty of code transformation steps developed, that I used in my work, and properly referred to and cited in my thesis. The results I can introduce in my thesis are based on my work in that research team. A prototype of the analyzing program built for transformations of Erlang code was made available to me, and I could develop further the data structure used by the analyzer to create the first version of my analyzing algorithm. This version was able to measure complexity, and later inspired many ideas to create the transformational language and the methods of querying this data. The methods and algorithms introduced in this thesis form the base of a program called RefactorErl [33], that is currently still under development, though already being used in industrial environment as a prototype software system, and is a grant application supported by ELTE IKKK, KMOP-1.1.2-08/1-2008-0002 and Ericsson Hungary. Antecedent of the research subject Functional programming languages, thus Erlang as well, contain several special program constructs, that are unheard of in the realm of object-oriented and imperative languages. The special syntactic elements make functional languages different, these attributes contribute to those being interesting or extraordinary, but also due to these, some of the known complexity measures are not, or only through modifications usable to measure code. This does not mean that complexity measures are not developed to these languages, but very few of the existing ones are generic enough to be used with any functional language [39, 35, 34] language-independently, therefore with Erlang as well, because most of these only work well with one specific language, thus have low efficiency with Erlang codes. For all of this I needed to define the measures of complexity that can be utilized with this paradigm, and create new ones as necessary.

4 There are tools for measuring software complexity, like Eclipse [41], or the software created by Simon, Steinbrückner and Lewerentz, that implements several complexity measures that help the users in measurement. The aim of the Crocodile [38] project is to create a program that helps to efficiently analyze source code, therefore it can be used quite well to makes measurements after code transformations. Tidier [13, 14] is an automatic source code analyzer, and transformer tool, that is capable of automatically correcting source code, eliminating the syntactic errors static analysis can find, but neither software/method uses complexity measures for source code analysis and transformation. This environment raised the demand for a complex and versatile tool, that is capable of measuring the complexity of Erlang codes, and based on these measurements localize as well as automatically or semi-automatically correct unmanageably complex parts. The methods used While making the collection of complexity measures and developing new ones, I researched the attributes of Erlang programs, and tried to find the complexity measures for every possible code construct that describe those properly. After managing the ones deemed important, with careful observation of the relationship between them I either introduced a new measure, or transformed the existing ones so that they could be used with Erlang language too. I defined the resulting measurement system with mathematical methods, and implemented each individually. Using the completed analyzer I validated every measure with various methods to assert the measurements are all proper ones. The results gained from this validation is detailed in my thesis. To measure the complexity, I created a high-level structured query language, and extended the analyzer with it. I analyzed the effect of various program transforming steps, and based on these I created the transformational programming language, that made writing transformational scripts possible and to automatically optimize source code. These scripts improve code quality based on complexity measures. The algorithm in the theses measuring structural complexity, the textual query language and its extension, the automatic transformational algorithm that runs the scripts, the automatic error-correcting methods, and the code complexity based errordetection, implemented in RefactorErl, are in their entirety my own work. Each of the theses were published in journals and presented at conferences as mentioned in the bibliography.

5 1 Thesis 1. - Developing and measuring metrics that can be used with Erlang language, and the creation of the query language While extending the semantic graph [8] in the analyzing algorithm of RefactorErl, I introduced a data structure, that can record the expected and the measured complexity measures of source code, and can mark the unmanageable/difficult code parts. With the modification of existing complexity measures, and making new ones, I created a complex measure system to calculate the complexity related attributes of Erlang, and of possibly every program construct it uses. Besides presenting the semantic graph, and its formal definition, I have detailed a low level language capable of traversing the graph with path expressions necessary to measure complexity measures. I devised a special structured query language to be able to access the semantic graph containing the processed source code on a higher abstraction layer of complexity measurements. MetricQuery Show for Type Show show metric Type module module function function Figure 1: The syntax of the query language I presented the syntax of this language, the possible queries it can define, the filters that can be used with it, and the merits of using them. Gyorsendezés show fun_return_points for function ({ a, quicksort,1}, { a, split,3}) sum Figure 2: Querying the return point of a function with the structured query language. The premise of the queries and the query language is that one can call, complexity measurement functions on the series of elements in the semantic graph of the processed source code. The runtime environment of the defined query language is coded in a functional language (Erlang), and provided an interface to run queries. The algorithm analyzing complexity is able to store the calculated complexity values, to reduce the resources needed to process more difficult analyzes. Storing the measures so, is an effective method, because it can track changes made to the source code and to recalculate automatically the complexity of only the modified

6 parts. This characteristic holds many possibilities. If the modification applied to the analyzed source code results in an unnecessary increase of complexity, it can highlight this complication, and also this attribute of the analyzer holds the possibility to apply automatic program transformations. Thesis 2. - Localizing complex code parts, and the effect of program transformations aimed at code refactoring on code quality I created an analyzer that reveals inadequate programming style or unmanageably complex program constructs during the whole lifecycle of the code using complexity measures describing the program. I devised a rule set, with which the analyzing processes in every measurements only perform on the sub-graph that directly was influenced by the transformational steps changing the code. The algorithm is also based upon the analysis of the semantic graph built from the source code (that, in this case, is naturally based on the measurements of structural complexity), but at this stage we can define default complexity measures, and these defaults are compared to the actual measured values of the code, therefore the differences can be indicated. The impact analysis of the transformations is theoretical, but based on conclusions, still, these statements are proven by running tests and interpreting the results on the implemented analyzing prototype. 2 Thesis 3. - Automatic source code transformation based on software complexity metrics, and the elaboration of refactoring transformational schemes. I created an algorithm measuring code complexity in Erlang programs, that provides automatic code transformations based on these measures. I created a script language, that can calculate the structural complexity of Erlang source codes, and based on the resulting outcome providing the descriptions of transformational steps. With the help of this language we can describe automatic code transformations that are based on code complexity measurements. I defined the syntax of the language that can describe the series of steps in these automatic code refactoring, that are complexity measurement based, and presented the principle of operation of the analyzer and run-time providing algorithm.

7 Query MetricQuery OptQuery OptQuery Opti Where Limit Opti optimize Transformation Transformation TransformationName TransformationName Params Params (Attr, ValueList) Where where Cond Cond Metric Rel CondValue Cond LogCon Cond Limit limit Int Figure 3: The syntax of transformational scripts. Besides the introduction of the syntax and use cases, I presented what results we can achieve using this language. The transformational language consists of sections, each of which has three parts. The first, starting with the keyword optimize, we instruct it which transformation and its parameters are we trying to use in the current step. optimize extract_fun (expr_type, case_expr) where max_depth_of_cases > 3 limit 2 optimize extract_fun where max_depth_of_cases > 3 and number_of_fun < 20 limit 3 Figure 4: The script performing the automatic transformation. In the second part, starting with the where label we can define conditions based on complexity measures, that specify which nodes take part in the transformational process. These conditions can relate to functions or module type nodes. This part runs the functions built into the algorithms, that analyze the whole source code, choose the appropriate graph nodes, and with those and the type of transformation it produces the parameters described in the optimize part that are necessary to complete a particular step, and furthermore, besides the collection of parameters, stop the running of scripts based on a customizable rule set.

References 8 The third part starting with the limit keyword controls the running of the scripts so, that this parameter limits the iteration step number. That is needed when the constrains in the where clause does not stop the transformational process. After defining and implementing the language, I created several scripts solving source code transformational problems that are based on complexity measures, and presented their run-time results, proving their usability. References [1] Roland Király: Results of complexity metric based automatic source code transformations. Annales Mathematicae et Informaticae 42 (2013) (accepted) [2] Tóth, M., Bozó, I., Horváth, Z., Kitlei, R., Király, R., Horpácsi, D., and Kőszegi, J.: RefactorErl: a source code analyser and transformer tool Poster at the High Speed Network Workshop 2011, Budapest, Hungary, May 2011 [3] Roland Király, Róbert Kitlei. Metric Based optimalization of functional source code. Annales Mathematicae et Informaticae 37 (2011) Pages: 59-74 [4] István Bozó, Dániel Horpácsi, Zoltán Horváth, Judit Kõszegi, Roland Király, Róbert Kitlei, Máté Tejfel, Melinda Tóth,. Haladó technológiák szoftverrendszerek forráskódú elemzésére A RefactorErl hatékonyságának és felhasználói felületének továbbfejlesztése Az Ericsson Magyarország Kft megbízásából és támogatásával a KMOP-1.1.2-08/1-2008-0002 projekt keretében az ERFA támogatásával Tech report 2011 Ericsson Hungary [5] Király, R., Kitlei R.: Complexity measurments for functional code 8th Joint Conference on Mathematics and Computer Science (MaCS 2010) refereed, and the proceedings will have ISBN classification July 14-17, 2010 [6] Király, R., Kitlei R.: Implementing structural complexity metrics in Erlang. 10 ICAI 2010 8th International Conference on Applied Informatics to be held in Eger, Hungary January 27-30, 2010 [7] Király, R. and Kitlei, R.: Implementing structural complexity metrics for Erlang Poster on the 8th International Conference on Applied Informatics, ICAI 2010, 2010 [8] Zoltán Horváth, László Lövei Tamás Kozsik, Roland Király, Melinda Tóth, Róbert Kitlei, Dániel Horpácsi, István Bozó. Extended semantic queries on Erlang programs and comprehensive testing of RefactorErl. Tech. Report 2010. Ericsson Hungary 2010. [9] Király Roland, Funkcionális programozási nyelvek EKF TTK TAMOP412 2010 120 oldal.

References 9 [10] Zoltán Hernyák, Roland Király. Teaching programming language in grammar schools. Annales Mathematicae et Informaticae 36 (2009) Pages: 163-174 [11] Horváth, Z., Lövei, L., Kozsik, T., Kitlei, R., Víg, A., Nagy, T., Tóth, M., and Király, R.: Modeling semantic knowledge in Erlang for refactoring. In Knowledge Engineering: Principles and Techniques, Proceedings of the International Conference on Knowledge Engineering, Principles and Techniques, KEPT 2009, volume 54(2009) Sp. Issue, Studia Universitatis Babeş-Bolyai, Series Informatica, pages 7 16, Cluj-Napoca, Romania, Jul 2009 [12] Lövei, L., Tóth, M., Horváth, Z., Kozsik, T., Király, R., Kitlei, R., Bozó, I., Hoch, C., and Horpácsi, D.: Reengineering legacy Erlang code by refactoring. Central Europen Functional Programming Summer School, May 2009. [13] Thanassis Avgerinos, Konstantinos F. Sagonas Cleaning up Erlang code is a dirty job but somebody s gotta do it. Erlang Workshop 2009: 1-10 [14] Konstantinos F. Sagonas, Thanassis Avgerinos Automatic refactoring of Erlang programs. PPDP 09 Proceedings of the 11th ACM SIGPLAN conference on Principles and practice of declarative programming 2009: 13-24 [15] Zoltán Horváth, László Lövei Tamás Kozsik, Roland Király, Melinda Tóth, Róbert Kitlei, Dániel Horpácsi, István Bozó. Complexity Metrics and simple semantic queries for Erlang. Report Ericsson Hungary 2009. [16] Tamás Kozsik, Zoltán Csörnyei, Zoltán Horváth, Roland Király, Róbert Kitlei, László Lövei, Tamás Nagy, Melinda Tóth, Anikó Víg Use Cases for Refactoring in Erlang. In Central European Functional Programming School, volume 5161/2008, Lecture Notes in Computer Science, pages 250 285, (2008) [17] R. Kitlei, L. Lövei, M Tóth, Z. Horváth, T. Kozsik, T. Kozsik, R. Király, I. Bozó, Cs. Hoch, D. Horpácsi. Automated Syntax Manipulation in RefactorErl. 14th International Erlang/OTP User Conference. Stockholm, November 13, 2008. [18] Lövei, L., Hoch, C., Köllö, H., Nagy, T., Nagyné-Víg, A., Kitlei, R., and Király, R.: Refactoring Module Structure In 7th ACM SIGPLAN Erlang Workshop, 2008 [19] Zoltán Horváth, László Lövei, Tamás Kozsik, Róbert Kitlei, Anikó Nagyné Víg, Tamás Nagy, Melinda Tóth, and Roland Király. Building a Refactoring Tool for Erlang. In K. Mens, M. van den Brand, A. Kuhn, H.M. Kienle, and R. Wuyts, editors, 1st International Workshop on Academic Software Development Tools and Techniques, 2008. 11 pages. [20] Lövei, L., Hoch, C., Köllő, H., Nagy, T., Nagyné-Víg, A., Horpácsi, D., Kitlei, R., and Király, R.: Refactoring Module Structure In Proceedings of the 7th

References 10 ACM SIGPLAN workshop on Erlang, pages 83 89, Victoria, British Columbia, Canada, Sep 2008. [21] Lövei, L., Hoch, C., Köllö, H., Nagy, T., Nagyné-Víg, A., Horpácsi, D., Kitlei, R., and Király, R.: Refactoring module structure in.:proceedings of the 7th ACM SIGPLAN workshop on ERLANG Columbia, Canada, (2008) [22] Zoltán Horváth, Zoltán Csörnyei, Roland Király, Róbert Kitlei, Tamás Kozsik, László Lövei, Tamás Nagy, Melinda Tóth, and Anikó Víg.: Use cases for refactoring in Erlang, To appear in Lecture Notes in Computer Science, (2008) [23] R. Kitlei, L. Lövei, M Tóth, Z. Horváth, T. Kozsik, T. Kozsik, R. Király, I. Bozó, Cs. Hoch, D. Horpácsi.: Automated Syntax Manipulation in RefactorErl. 14th International Erlang/OTP User Conference. Stockholm, (2008) [24] Lövei, L., Hoch, C., Köllö, H., Nagy, T., Nagyné-Víg, A., Kitlei, R., and Király, R.: Refactoring Module Structure In 7th ACM SIGPLAN Erlang Workshop, (2008) [25] Zoltán Horváth, László Lövei Tamás Kozsik, Anikó Nagyné Víg, Tamás Nagy, Roland Király, Melinda Tóth, Róbert Kitlei, Dániel Horpácsi, Hanna Kölló, Krisztián Tóth, Csaba Hoch.: Erlang programok modulszerkezetének refaktorálása, Technical report (2008) [26] Horváth, Z., Lövei, L., Kozsik, T., Kitlei, R., Víg, A., Nagy, T., Tóth, M., and Király, R.: Building a refactoring tool for Erlang In Workshop on Advanced Software Development Tools and Techniques, WASDETT 2008, (2008) [27] Huiqing Li, Simon Thompson, György Orosz, Melinda Tóth.: Refactoring with wrangler, updated: data and process refactorings, and integration with Eclipse Proceedings of the 7th ACM SIGPLAN workshop on ERLANG (2008) [28] Lövei, L., Horváth, Z., Kozsik, T., Király, R., Víg, A., and Nagy, T.: Refactoring in Erlang, a Dynamic Functional Language In Proceedings of the 1st Workshop on Refactoring Tools, pages 4546, Berlin, Germany, 2007 extended abstract [29] László Lövei, Zoltán Horváth, Tamás Kozsik, Roland Király, and Róbert Kitlei. Static rules of variable scoping in Erlang. In Emőd Kovács, Péter Olajos, and Tibor Tómács, editors, Proceedings of the 7th International Conference on Applied Informatics, volume 2, pages 137-145, 2008. rev: Zbl pre05662517. [30] Tamás Kozsik, Zoltán Csörnyei, Zoltán Horváth, Roland Király, Róbert Kitlei, László Lövei, Tamás Nagy, Melinda Tóth, and Anikó Víg. Use Cases for Refactoring in Erlang. In Central European Functional Programming School (The Second Central European Summer School, CEFP 2007, Cluj, Romania, June 23-30, 2007), Revised Selected Lectures, volume 5161 of Lecture Notes in Computer Science, pages 250-285. Springer Berlin/Heidelberg, 2008. rev: Zbl 1170.68414, DBLP

References 11 [31] László Lövei, Zoltán Horváth, Tamás Kozsik, and Roland Király. Introducing records by refactoring. In Proceedings of the 2007 ACM SIGPLAN Erlang Workshop, pages 18-28. ACM Press, 2007. [32] Lövei, L., Horváth, Z., Kozsik, T., Király, R., Víg, A., and Nagy, T.: Refactoring in Erlang, a Dynamic Functional Language In Proceedings of the 1st Workshop on Refactoring Tools, pages 45 46, Berlin, Germany, extended abstract, poster (2007) [33] T. Kozsik, Z. Horváth, L. Lövei, T. Nagy, Z. Csörnyei, A. Víg, R. Király, M. Tóth, R. Kitlei.. Refactoring Erlang programs. CEFP 07, Kolozsvár (2007) [34] Ryder, C., Thompson, S. Software Metrics: Measuring Haskell, In Marko van Eekelen and Kevin Hammond, editors, Trends in Functional Programming (September 2005) [35] Ryder, C. Software Measurement for Functional Programming, PhD thesis, Computing Lab, University of Kent, Canterbury, UK 2004) [36] Fóthi Á., Nyéki-Gaizler J., Porkoláb Z. The Structured Complexity of Object Oriented Programs Computers and Mathematics with applications, (2002) [37] Frank Simon, Frank Steinbrückner, Claus Lewerentz Metrics based refactoring IEEE Computer Society Press 2001 30-38, [38] Claus Lewerentz, Frank Simon A Product Metrics Tool Integrated into a Software Development Environment Object-Oriented Technology (ECOOP 98 Workshop Reader), LNCS 1543 Springer-Verlag 256 257 [39] Klaas van den Berg.: Software Measurement and Functional Programming, PhD Thesis University of Twente (1995) [40] Erlang - Dynamic Functional Language http://www.erlang.org [41] Eclipse Foundation http://www.eclipse.org/