A Systematic Review of the Literature of the Techniques to Perform Transformations in Software Engineering / Uma revisão sistemática da literatura das técnicas para realizar transformações na engenharia de software

Reudismam Rolim de Sousa

Abstract


Along with software evolution, developers may do repetitive edits. These edits can be identical or similar to different codebase locations, which may occur as developers add features, refactor, or fix a bug. Since some of these edits are not present in Integrated Development Environments (IDEs), they are often performed manually, which is time-consuming and error-prone. In order to help developers to apply repetitive edits, some techniques were proposed. In this work, we present a systematic review of the literature of the techniques to do transformations in software engineering. As a result, this systematic review returned 51 works ranging from the domains programming-by-examples, linked editing, API usage, bug fixing, complex refactoring, and complex transformations, which can be used to help tools' designer in the proposition of new approaches.

 

 


Keywords


Systematic Review of the Literature, Transformations, Software Engineering.

Full Text:

PDF

References


[Alkhalid et al. 2010] Alkhalid, A., Alshayeb, M., and Mahmoud, S. (2010). Software re factoring at the function level using new adaptive k-nearest neighbor algorithm. International Journal of Advances in Software Engineering, 41(10-11):1160–1178.

[Andersen and Lawall 2008] Andersen, J. and Lawall, J. L. (2008). Generic patch inference. In Proceedings of the 2008 23rd IEEE/ACM International Conference on Automated Software Engineering, ASE ’08, pages 337–346, Washington, DC, USA. IEEE Com- puter Society.

[Boshernitsan et al. 2007] Boshernitsan, M., Graham, S. L., and Hearst, M. A. (2007). Aligning development tools with the way programmers think about code changes. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, CHI ’07, pages 567–576, New York, NY, USA. ACM.

[Bravenboer et al. 2008] Bravenboer, M., Kalleberg, K. T., Vermaas, R., and Visser, E. (2008). Stratego/XT 0.17. A language and toolset for program transformation. Science of Computer Programming, 72(1-2):52–70.

[Brown et al. 2013] Brown, C., Hammond, K., Danelutto, M., Kilpatrick, P., Schöner, H., and Breddin, T. (2013). Paraphrasing: Generating parallel programs using refactoring. In Proceedings of the 10th International Symposium on Formal Methods for Components and Objects, FMCO ’11, pages 237–256. Springer Berlin Heidelberg, Berlin, Heidelberg.

[Bruch et al. 2009] Bruch, M., Monperrus, M., and Mezini, M. (2009). Learning from examples to improve code completion systems. In Proceedings of the the 7th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on The Foundations of Software Engineering, ESEC/FSE ’09, pages 213– 222, New York, NY, USA. ACM.

[Cordy 2006] Cordy, J. R. (2006). Source transformation, analysis and generation in TXL. In Proceedings of the 2006 ACM SIGPLAN Symposium on Partial Evaluation and Semantics-based Program Manipulation, PEPM ’06, pages 1–11, New York, NY, USA. ACM.

[Cossette et al. 2014] Cossette, B., Walker, R., and Cottrell, R. (2014). Using structural generalization to discover replacement functionality for API evolution.

[Dagenais and Robillard 2008] Dagenais, B. and Robillard, M. P. (2008). Recommending adaptive changes for framework evolution. In Proceedings of the 30th International Conference on Software Engineering, ICSE ’08, pages 481–490, New York, NY, USA. ACM.

[Wit et al. 2009] de Wit, M., Zaidman, A., and van Deursen, A. (2009). Managing code clones using dynamic change tracking and resolution. In Proceedings of the 2009 IEEE International Conference on Software Maintenance, ICSM ’09, pages 169–178, Piscataway, NJ, USA. IEEE Press.

[Duala-Ekoko and Robillard 2010] Duala-Ekoko, E. and Robillard, M. P. (2010). Clone region descriptors: Representing and tracking duplication in source code. ACM Transactions on Software Engineering and Methodology, 20(1):3:1–3:31.

[Erwig and Ren 2007] Erwig, M. and Ren, D. (2007). An update calculus for expressing type-safe program updates. Science of Computer Programming, 67(2-3):199–222.

[Foster et al. 2012] Foster, S. R., Griswold, W. G., and Lerner, S. (2012). WitchDoctor: IDE support for real-time auto-completion of refactorings. In Proceedings of the 34th International Conference on Software Engineering, ICSE ’12, pages 222–232, Piscataway, NJ, USA. IEEE Press.

[Gabel and Su 2010] Gabel, M. and Su, Z. (2010). A study of the uniqueness of source code. In Proceedings of the Eighteenth ACM SIGSOFT International Symposium on Foundations of Software Engineering, FSE ’10, pages 147–156, New York, NY, USA. ACM.

[Ge et al. 2012] Ge, X., DuBose, Q. L., and Murphy-Hill, E. (2012). Reconciling manual and automatic refactoring. In Proceedings of the 34th International Conference on Software Engineering, ICSE ’12, pages 211–221, Piscataway, NJ, USA. IEEE Press.

[Hayashi et al. 2006] Hayashi, S., Saeki, M., and Kurihara, M. (2006). Supporting refactoring activities using histories of program modification. IEICE Transactions on Fundamentals of Electronics, Communications and Computer Sciences, 89-D(4):1403–1412.

[Hindle et al. 2012] Hindle, A., Barr, E. T., Su, Z., Gabel, M., and Devanbu, P. (2012). On the naturalness of software. In Proceedings of the 34th International Conference on Software Engineering, ICSE ’12, pages 837–847, Piscataway, NJ, USA. IEEE Press.

[Jeffrey et al. 2009] Jeffrey, D., Feng, M., Gupta, N., and Gupta, R. (2009). BugFix: A learning-based tool to assist developers in fixing bugs. In Proceedings of the 2009 IEEE 17th International Conference on Program Comprehension, ICPC ’09, pages 70–79, Piscataway, NJ, USA. IEEE Press.

[Joiner et al. 2014] Joiner, R., Reps, T., Jha, S., Dhawan, M., and Ganapathy, V. (2014). Efficient runtime-enforcement techniques for policy weaving. In Proceedings of the 22Nd ACM SIGSOFT International Symposium on Foundations of Software Engineering, FSE ’14, pages 224–234, New York, NY, USA. ACM.

[Kapur et al. 2010] Kapur, P., Cossette, B., and Walker, R. J. (2010). Refactoring references for library migration. In Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications, OOPSLA ’10, pages 726–738, New York, NY, USA. ACM.

[Kessentini et al. 2011] Kessentini, M., Kessentini, W., Sahraoui, H., Boukadoum, M., and Ouni, A. (2011). Design defects detection and correction by example. In Proceedings of the 19th IEEE International Conference on Program Comprehension, ICPC ’11, pages 81–90, Piscataway, NJ, USA. IEEE Press.

[Kim et al. 2013] Kim, D., Nam, J., Song, J., and Kim, S. (2013). Automatic patch generation learned from human-written patches. In Proceedings of the 35th International Conference on Software Engineering, ICSE ’13, pages 802–811, Piscataway, NJ, USA. IEEE Press.

[Kim et al. 2016] Kim, J., Batory, D., Dig, D., and Azanza, M. (2016). Improving refactoring speed by 10x. In Proceedings of the 38th International Conference on Software Engineering, ICSE ’16, pages 1145–1156, New York, NY, USA. ACM.

[Kim and Meng 2014] Kim, M. and Meng, N. (2014). Recommending Program Transformations to Automate Repetitive Software Changes, pages 1–31. Springer Berlin Hei- delberg, Berlin, Heidelberg.

[Kim et al. 2006] Kim, S., Pan, K., and Whitehead, Jr., E. E. J. (2006). Memories of bug fixes. In Proceedings of the 14th ACM SIGSOFT International Symposium on Foundations of Software Engineering, SIGSOFT ’06/FSE ’14, pages 35–45, New York, NY, USA. ACM.

[Kitchenham and Brereton 2013] Kitchenham, B. and Brereton, P. (2013). A systematic review of systematic review process research in software engineering. Information and Software Technology, 55(12):2049–2075.

[Kitchenham and Charters 2007] Kitchenham, B. and Charters, S. (2007). Guidelines for performing systematic literature reviews in software engineering. In Evidence-Based Software Engineering. Technical Report, EBSE, pages 1–65.

[LaPES 2017] LaPES (2017). Start: State of the art through systematic review.

A http://lapes.dc.ufscar.br/tools/start_tool.

[Le Goues et al. 2012] Le Goues, C., Dewey-Vogt, M., Forrest, S., and Weimer, W. (2012). A systematic study of automated program repair: Fixing 55 out of 105 bugs for $8 each. In Proceedings of the 34th International Conference on Software Engineering, ICSE ’12, pages 3–13, Piscataway, NJ, USA. IEEE Press.

[Li and Thompson 2012] Li, H. and Thompson, S. (2012). Let’s make refactoring tools user-extensible! In Proceedings of the Fifth Workshop on Refactoring Tools, WRT ’12, pages 32–39, New York, NY, USA. ACM.

[Li et al. 2015] Li, J., Wang, C., Xiong, Y., and Hu, Z. (2015). Swin: Towards type-safe Java program adaptation between apis. In Proceedings of the 2015 Workshop on Partial Evaluation and Program Manipulation, PEPM ’15, pages 91–102, New York, NY, USA. ACM.

[Liu et al. 2013] Liu, C., Yang, J., Tan, L., and Hafiz, M. (2013). R2fix: Automatically generating bug fixes from bug reports. In 6th IEEE International Conference on Software Testing, Verification and Validation, ICST ’13, pages 282–291, Piscataway, NJ, USA. IEEE Press.

[Long and Rinard 2016] Long, F. and Rinard, M. (2016). Automatic patch generation by learning correct code. Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, 51(1):298–312.

[Ma et al. 2016] Ma, S., Lo, D., Li, T., and Deng, R. H. (2016). CDRep: Automatic repair of cryptographic misuses in android applications. In Proceedings of the 11th ACM on Asia Conference on Computer and Communications Security, AsiaCCS 2016, Xían, China, May 30 - June 3, 2016, pages 711–722.

[Marin et al. 2009] Marin, M., Deursen, A., Moonen, L., and Rijst, R. (2009). An integrated crosscutting concern migration strategy and its semi-automated application to JHotDraw. Automated Software Engineering, 16(2):323–356.

[Medeiros et al. 2014] Medeiros, F., Ribeiro, M., Gheyi, R., and dos Santos Neto, B. F. (2014). A catalogue of refactorings to remove incomplete annotations. The Journal of Universal Computer Science, 20(5):746–771.

[Meng et al. 2015] Meng, N., Hua, L., Kim, M., and McKinley, K. S. (2015). Does automated refactoring obviate systematic editing? In Proceedings of the 37th International Conference on Software Engineering - Volume 1, ICSE ’15, pages 392–402, Piscataway, NJ, USA. IEEE Press.

[Meng et al. 2011] Meng, N., Kim, M., and McKinley, K. S. (2011). Systematic editing: Generating program transformations from an example. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’11, pages 329–342, New York, NY, USA. ACM.

[Meng et al. 2013] Meng, N., Kim, M., and McKinley, K. S. (2013). LASE: Locating and applying systematic edits by learning from examples. In Proceedings of the 35th International Conference on Software Engineering, ICSE ’13, pages 502–511, Piscataway, NJ, USA. IEEE Press.

[Mens and Tourwé 2004] Mens, T. and Tourwé, T. (2004). A survey of software refactoring.

IEEE Transactions on Software Engineering, 30(2):126–139.

[Monperrus 2015] Monperrus, M. (2015). Automatic Software Repair: a Bibliography. Technical Report hal-01206501, University of Lille.

[Morales et al. 2016] Morales, R., Soh, Z., Khomh, F., Antoniol, G., and Chicano, F. (2016). On the use of developers’ context for automatic refactoring of software anti-patterns. Journal of Systems and Software, pages.

[Negara et al. 2014] Negara, S., Codoban, M., Dig, D., and Johnson, R. E. (2014). Mining fine-grained code changes to detect unknown change patterns. In Proceedings of the 36th International Conference on Software Engineering, ICSE’14, pages 803–813, New York, NY, USA. ACM.

[Nguyen et al. 2016] Nguyen, A. T., Hilton, M., Codoban, M., Nguyen, H. A., Mast, L., Rademacher, E., Nguyen, T. N., and Dig, D. (2016). API code recommendation using statistical learning from fine-grained changes. In Proceedings of the 24th ACM SIG- SOFT International Symposium on Foundations of Software Engineering, FSE 2016, pages 511–522, New York, NY, USA. ACM.

[Nguyen and Nguyen 2015] Nguyen, A. T. and Nguyen, T. N. (2015). Graph-based statistical language model for code. In Proceedings of the 37th International Conference on Software Engineering, ICSE ’15, pages 858–868, Piscataway, NJ, USA. IEEE Press.

[Nguyen et al. 2013a] Nguyen, H. A., Nguyen, A. T., Nguyen, T. T., Nguyen, T. N., and Rajan, H. (2013a). A study of repetitiveness of code changes in software evolution. In Proceedings of 28th the IEEE/ACM International Conference on Automated Software Engineering, ASE ’13, pages 180–190, New York, NY, USA.

[Nguyen et al. 2013b] Nguyen, H. A., Nguyen, A. T., Nguyen, T. T., Nguyen, T. N., and Rajan, H. (2013b). A study of repetitiveness of code changes in software evolution. In Proceedings of the IEEE/ACM 28th International Conference on Automated Software Engineering, ASE ’17, pages 180–190.

[Nguyen et al. 2013c] Nguyen, H. A., Nguyen, H. V., Nguyen, T. T., and Nguyen, T. N. (2013c). Output-oriented refactoring in php-based dynamic web applications. In Proceedings of the 2013 IEEE International Conference on Software Maintenance, pages 150–159.

[Nguyen et al. 2012] Nguyen, H. A., Nguyen, T. T., Pham, N. H., Al-Kofahi, J., and Nguyen, T. N. (2012). Clone management for evolving software. IEEE Transactions on Software Engineering, 38(5):1008–1026.

[Nguyen et al. 2010a] Nguyen, H. A., Nguyen, T. T., Wilson, Jr., G., Nguyen, A. T., Kim, M., and Nguyen, T. N. (2010a). A graph-based approach to API usage adaptation. In Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications, OOPSLA ’10, pages 302–321, New York, NY, USA. ACM.

[Nguyen et al. 2010b] Nguyen, T. T., Nguyen, H. A., Pham, N. H., Al-Kofahi, J., and Nguyen, T. N. (2010b). Recurring bug fixes in object-oriented programs. In Proceedings of the 32nd IEEE/ACM International Conference on Software Engineering - Volume 1, ICSE ’10, pages 315–324, New York, NY, USA. ACM.

[Nguyen et al. 2009] Nguyen, T. T., Nguyen, H. A., Pham, N. H., Al-Kofahi, J. M., and Nguyen, T. N. (2009). Clone-aware configuration management. In Proceedings of the 2009 IEEE/ACM International Conference on Automated Software Engineering, ASE ’09, pages 123–134, Washington, DC, USA. IEEE Computer Society.

[Nita and Notkin 2010] Nita, M. and Notkin, D. (2010). Using twinning to adapt programs to alternative APIs. In Proceedings of the 32Nd IEEE/ACM International Conference on Software Engineering - Volume 1, ICSE ’10, pages 205–214, New York, NY, USA. ACM.

[O'Keeffe and í Cinnéide 2008] O'Keeffe, M. and í Cinnéide, M. (2008). Search-based refactoring for software maintenance. Journal of Systems and Software, 81(4):502–516.

[Ouni et al. 2013] Ouni, A., Kessentini, M., and Sahraoui, H. (2013). Search-based refactoring using recorded code changes. In Proceedings of the 2013 17th European Conference on Software Maintenance and Reengineering, CSMR ’13, pages 221–230, Washington, DC, USA. IEEE Computer Society.

[Ouni et al. 16] Ouni, A., Kessentini, M., Sahraoui, H., Inoue, K., and Deb, K. (16). Multi- criteria code refactoring using search-based software engineering: An industrial case study. ACM Transactions on Software Engineering and Methodology, 25(3):23:1– 23:53.

[Ouni et al. 2015] Ouni, A., Kessentini, M., Sahraoui, H., Inoue, K., and Hamdi, M. S. (2015). Improving multi-objective code-smells correction using development history. J. Syst. Softw., 105(C):18–39.

[Overbey et al. 2014] Overbey, J. L., Behrang, F., and Hafiz, M. (2014). A foundation for refactoring C with macros. In Proceedings of the 22Nd ACM SIGSOFT International Symposium on Foundations of Software Engineering, FSE ’14, pages 75–85, New York, NY, USA. ACM.

[Pakdeetrakulwong et al. 2014] Pakdeetrakulwong, U., Wongthongtham, P., and Siricharoen, W. V. (2014). Recommendation systems for software engineering: A survey from software development life cycle phase perspective. In The 9th International Conference for Internet Technology and Secured Transactions, (ICITST ’14), pages 137–142.

[Park et al. 2012] Park, J., Kim, M., Ray, B., and Bae, D.-H. (2012). An empirical study of supplementary bug fixes. In Proceedings of the 9th IEEE Working Conference on Mining Software Repositories, MSR ’12, pages 40–49, Piscataway, NJ, USA. IEEE Press.

[Ray et al. 2015] Ray, B., Nagappan, M., Bird, C., Nagappan, N., and Zimmermann, T. (2015). The uniqueness of changes: Characteristics and applications. In Proceedings of the 12th Working Conference on Mining Software Repositories, MSR ’15, pages 34–44, Piscataway, NJ, USA. IEEE Press.

[Raychev et al. 2013] Raychev, V., Schäfer, M., Sridharan, M., and Vechev, M. (2013). Refactoring with synthesis. In Proceedings of the 28th ACM SIGPLAN International Conference on Object Oriented Programming Systems Languages and Applications, OOPSLA ’13, pages 339–354, New York, NY, USA. ACM.

[Robbes and Lanza 2008] Robbes, R. and Lanza, M. (2008). Example-based program trans- formation. In Proceedings of the 11th International Conference on Model Driven Engineering Languages and Systems, volume 5301 of MoDELS ’08, pages 174–188. Springer Berlin Heidelberg, Berlin, Heidelberg.

[Ruhroth et al. 2011] Ruhroth, T., Wehrheim, H., and Ziegert, S. (2011). Rel: A generic refactoring language for specification and execution. In 2011 37th EUROMICRO Conference on Software Engineering and Advanced Applications, pages 83–90.

[Santos et al. 2015] Santos, G., Etien, A., Anquetil, N., Ducasse, S., and Valente, M. T. (2015). Recording and replaying system specific, source code transformations. In 2015 IEEE 15th International Working Conference on Source Code Analysis and Manipulation, SCAM ’15, pages 221–230, Piscataway, NJ, USA. IEEE Press.

[Schäfer et al. 2011] Schäfer, M., Sridharan, M., Dolby, J., and Tip, F. (2011). Refactoring Java programs for flexible locking. In Proceedings of the 33rd International Conference on Software Engineering, ICSE ’11, pages 71–80, New York, NY, USA. ACM.

[Schulze et al. 2013] Schulze, S., Lochau, M., and Brunswig, S. (2013). Implementing refactorings for FOP: Lessons learned and challenges ahead. In Proceedings of the 5th International Workshop on Feature-Oriented Software Development, FOSD ’13, pages 33–40, New York, NY, USA. ACM.

[Steimann et al. 2011] Steimann, F., Kollee, C., and von Pilgrim, J. (2011). A refactoring constraint language and its application to Eiffel. In Proceedings of the 25th European Conference on Object-oriented Programming, ECOOP’11, pages 255–280, Berlin, Heidelberg. Springer Berlin Heidelberg.

[Sun et al. 2008] Sun, B., Chang, R.-Y., Chen, X., and Podgurski, A. (2008). Automated support for propagating bug fixes. In Proceedings of the 2008 19th International Symposium on Software Reliability Engineering, ISSRE ’08, pages 187–196, Washington, DC, USA. IEEE Computer Society.

[Tansey and Tilevich 2008] Tansey, W. and Tilevich, E. (2008). Annotation refactoring: In- ferring upgrade transformations for legacy applications. In Proceedings of the 23rd ACM SIGPLAN Conference on Object-oriented Programming Systems Languages and Applications, OOPSLA ’08, pages 295–312, New York, NY, USA. ACM.

[Toomim et al. 2004] Toomim, M., Begel, A., and Graham, S. (2004). Managing duplicated code with linked editing. In Proceedings of the 2004 IEEE Symposium on Visual Languages and Human Centric Computing, VL-HCC ’14, pages 173–180, Piscataway, NJ, USA. IEEE Press.

[Vidal and Marcos 2012] Vidal, S. A. and Marcos, C. A. (2012). Building an expert system to assist system refactorization. Expert Systems with Applications, 39(3):3810–3816.

[Vidal and Marcos 2013] Vidal, S. A. and Marcos, C. A. (2013). Toward automated refactoring of crosscutting concerns into aspects. Journal of Systems and Software, 86(6):1482–1497.

[Wang et al. 2016] Wang, C., Jiang, J., Li, J., Xiong, Y., Luo, X., Zhang, L., and Hu, Z. (2016).

Transforming Programs between APIs with Many-to-Many Mappings. In Krishnamurthi, S. and Lerner, B. S., editors, 30th European Conference on Object- Oriented Programming (ECOOP 2016), volume 56 of Leibniz International Pro- ceedings in Informatics (LIPIcs), pages 25:1–25:26, Dagstuhl, Germany. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik.

[Wloka et al. 2009] Wloka, J., Sridharan, M., and Tip, F. (2009). Refactoring for reentrancy. In Proceedings of the the 7th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on The Foundations of Software Engineering, ESEC/FSE ’09, pages 173–182, New York, NY, USA. ACM.

[Wu et al. 2015] Wu, L., Wu, Q., Liang, G., Wang, Q., and Jin, Z. (2015). Transforming code with compositional mappings for API-library switching. In 39th IEEE Annual Computer Software and Applications Conference, COMPSAC 2015, Taichung, Taiwan, July 1-5, 2015. Volume 2, pages 316–325.

[Xia and Lo 2016] Xia, X. and Lo, D. (2016). An effective change recommendation approach for supplementary bug fixes. Automated Software Engineering, pages 1–44.

[Xing and Stroulia 2007] Xing, Z. and Stroulia, E. (2007). API-evolution support with diff- catchup. IEEE Transactions on Software Engineering, 33(12):818–836.

[Zibran and Roy 2012] Zibran, M. F. and Roy, C. K. (2012). The road to software clone management: A survey. Technical report, pages 1–68.




DOI: https://doi.org/10.34117/bjdv6n7-361

Refbacks

  • There are currently no refbacks.