Kódrefaktorálás

A Wikipédiából, a szabad enciklopédiából
Ugrás a navigációhoz Ugrás a kereséshez

A kódrefaktorálás a meglévő számítógépes forráskód átalakításának folyamata – az elemek, összetevők (faktorok) megváltoztatása – a külső viselkedés módosulása nélkül. A refaktorálás célja a kód nem funkcionális tulajdonságainak (felépítésének, összetételének és/vagy implementációjának) javítása, miközben megőrzi a szoftver funkcionalitását. A kódrefaktorálás potenciális előnyei közé tartozik, hogy javítja a kód olvashatóságát és csökkenti a bonyolultságát; így könnyebben karbantartható a forráskód, és egyszerűbb, letisztultabb vagy kifejezőbb belső architektúra vagy objektummodell hozható létre a bővíthetőség javítása érdekében.

Refaktorálás közben jellemzően szabványosított kisebb változtatások sorozatát (micro-refactoring) alkalmazzák, amelyek mindegyike (általában) a forráskód apró változtatását jelenti, amely megőrzi a szoftver viselkedését, vagy legalábbis nem változtatja meg a funkcionális követelményeknek való megfelelését. Számos telepítési környezet automatizált támogatást nyújt ezen kis változtatások mechanikai aspektusainak végrehajtásához. Ha jól hajtják végre, akkor a kódrefaktorálás segíthet a szoftverfejlesztőknek a rendszerben nyugvó hibák vagy biztonsági rések felfedezésében és kijavításában, az alapjául szolgáló logika egyszerűsítése által, és a szükségtelen bonyolultsági szintek kiküszöbölésével. Ha rosszul van végrehajtva, akkor megváltoztathatja a szoftver funkcionalitását és/vagy újabb hibákat idézhet elő.

„A kód dizájnjának folyamatos javításával egyre egyszerűbbé és egyszerűbbé tesszük a vele való munkát. Ez éles ellentétben áll azzal, ami általában történik: kevés refaktorálás, és nagy hangsúly az új funkciók gyors implementációján. Ha ráérzel a folyamatos refaktorálás higiénikus szokására, rájössz, hogy sokkal könyebb lesz bővíteni és karbantartani a kódot.”
   – Joshua Kerievsky, Refactoring to Patterns[1]

Motiváció[szerkesztés]

A refaktorálásra általában akkor kerül sor, ha „gyanús kódot” (code smell) észlelnek.[2] Például egy adott metódus túl hosszú, vagy nagyban hasonlít egy másikra.. Amint felismerték, ezeket a problémákat a forráskód refaktorálásával vagy újraírásával oldják meg, mely ugyanúgy viselkedik, de már nem gyanús.

Egy hosszabb metódusból egy vagy több kisebb szubrutint lehet kiemelni; duplikált rutinok esetén a másolat eltávolítható és helyettesíthető egy megosztott függvénnyel. A refaktorálás elmulasztása „technikai adósság” halmozódását eredményezheti; másrészről a refaktorálás a technikai adósság visszafizetésének egyik elsődleges eszköze.[3]

Előnyök[szerkesztés]

A refaktorálás előnyeinek két általános kategóriája van.

  1. Karbantarthatóság. A hibák javítása könnyebb, ha a forráskód könnyen olvasható, és a szerző szándéka könnyen megragadható.[4] Ezt úgy lehet elérni, hogy a nagyméretű monolitikus eljárásokat rövid, jól megnevezett, egycélú metódusok sorozatává redukálják. Az is segít, ha egy metódust egy megfelelőbb osztályba helyezünk, vagy eltávolítjuk a félrevezető megjegyzéseket.
  2. Bővíthetőség. Az alkalmazás funkcióit könnyebb kibővíteni, ha felismerhető tervezési mintákat használ, és bizonyos rugalmasságot biztosít olyan helyeken, ahol korábban nem létezett ilyen.[5]

A teljesítménytervezés (performance engineering) képes megszüntetni a programok hatékonysági hiányosságait, az úgynevezett szoftverfelfúvódást (software bloat), amely a hagyományos szoftverfejlesztési stratégiákból ered (az alkalmazás fejlesztési idejének minimalizálása a futási idő helyett). A teljesítménytervezés a szoftvert a futtatásához szükséges hardverhez is igazíthatja, például a párhuzamos architektúrák kihasználása érdekében.[6]

Kihívások[szerkesztés]

A refaktoráláshoz ki kell emelni a szoftverrendszer struktúráját, az adatmodelleket és az alkalmazáson belüli függőségeket, hogy tudomást szerezzünk a meglévő szoftverrendszer működéséről.[7] A távozó csapattagok miatt a fejlesztőknek hiányos vagy pontatlan ismereteik vannak a rendszer jelenlegi állapotáról és a tervezési döntésekről. A kódmegújítási tevékenységek további erőfeszítéseket igényelhetnek ezen ismeretek visszanyerése érdekében.[8] A refaktorálási tevékenységek arhitekturális módosításokat eredményeznek, amelyek rontják a szoftverrendszer szerkezeti felépítését, ez pedig befolyásolja például a karbantarthatóságot és az áttekinthetőséget, amelyek a szoftverrendszerek teljes újrafejlesztéséhez vezethetnek.[9]

A kódrefaktoráló tevékenységeket szoftveres intelligencia biztosíthatja, amely eszközöket és technikákat használ, hogy adatokat szolgáltasson a kód algoritmusairól és szekvenciáiról.[10] A szoftverrendszer felépítésének, az adatmodellek és az összetevőkön belüli függőségek belső állapotának áttekinthető formátumban való megjelenítése kritikus rész a magas szintű megértés kialakulásában, mivel ez alapján tudható meg, hogy mit kell módosítani, és hogyan.[11]

Tesztelés[szerkesztés]

Az automatikus egységteszteket be kell állítani a refaktorálás előtt, hogy megbizonyosodjanak arról, hogy a rutinok továbbra is a várt eredményeket adják.[12] Az egységtesztelés még nagymértékű refaktorálás esetén is stabilitást eredményezhet, ha a változtatásokat kis lépésekben végzik. Gyakori stratégia a több projektet átfogó refaktorálások esetén hogy az összes projektet egyetlen adattárban (repository) tárolják.[13]

Az egységtesztek végrehajtása során a refaktorálás egy iteratív ciklus formáját ölti, amely során apró kódváltoztatásokat végeznek, teszteléssel megbizonyosodnak róla, hogy ez nem változtatta meg a viselkedést, majd folytatják a változtatásokat. Ha egy teszt bármely pontján kudarcot vall, akkor az utolsó apró változtatást visszavonják és más módon ismétlik meg. Ahhoz, hogy ez az iteratív folyamat praktikus legyen, a teszteket nagyon gyorsan kell lefuttatni, különben a programozók az idejük nagy részét a tesztek végrehajtására fordítanák. Az extrém programozás és más agilis szoftverfejlesztések támogatói ezt a tevékenységet a szoftverfejlesztési folyamat szerves részeként írják le.

Technikák[szerkesztés]

Íme néhány példa a mikro-refaktorokra; ezek közül néhány csak bizonyos nyelvekre vagy nyelvtípusokra vonatkozik. Hosszabb lista megtalálható Martin Fowler könyvében és a weboldalon.[14] Számos fejlesztési környezet automatizált támogatást nyújt ezeknek a mikro-refaktoroknak. Például egy programozó rákattinthat egy változó nevére, majd a helyi menüből kiválaszthatja az „Encapsulate field” refaktoráló funkciót. A fejlesztői környezet ezután további részleteket kér, általában ésszerű alapértelmezésekkel és a kódváltozások előnézetével. Miután a programozó megerősítette, elvégzi a szükséges változtatásokat a kód egészében.

  • Technikák, amelyek lehetővé teszik a megértést
    • Programfüggőségi gráf – az adatok és a vezérlőfüggőségek explicit ábrázolása[15]
    • Rendszerfüggési grafikon – a programfüggőségi gráfok közötti eljáráshívások ábrázolása[16]
    • Szoftverintelligencia – Segít megérteni az alkalmazáson belüli függőségeket
  • További absztrakciót lehetővé tevő technikák
    • Adatmező egységbe zárása – rákényszeríti a kódot, hogy a mezőt csak getter és setter metódusokkal lehessen elérni
    • Típus általánosítása – általánosabb típusok létrehozása a további kódmegosztás érdekében
    • Típusellenőrző kód cserélése állapotra/stratégiára[17]
    • Feltételek cserélése polimorfizmusra[18]
  • A kód logikusabb részekre bontása
    • A kód felbontása újrafelhasználható szemantikai egységekre, amelyek tiszta, jól meghatározott, egyszerűen használható felületeket tartalmaznak
    • Egy nagyobb osztály egy részének kiemelése és velük egy új osztály létrehozása
    • Egy nagyobb metódus (vagy függvény) egy részének kiemelése és velük egy új metódus létrehozása
  • Nevek és helyek javítására
    • Metódusok vagy adatmezők áthelyezése egy megfelelőbb osztályba vagy forrásfájlba
    • Metódusok vagy adatmezők neveinek megváltoztatása olyanra, amelyek jobban leírják a céljukat
    • Pull up – áthelyezés szülőosztályba (objektumorientált programozásban)
    • Push down – áthelyezés gyerekosztályba (objektumorientált programozásban)[12]
  • Kódduplikáció automatikus felismerése[19]

Hardver-refaktorálás[szerkesztés]

Míg a refaktorálás kifejezés eredetileg kizárólag a szoftverkód átírására utalt, az utóbbi években a hardverleíró nyelveken (HDL) írt kódot is refaktorálták. A hardver-refaktorálás kifejezést rövidített kifejezésként használják a hardverleíró nyelveken történő refaktorálására. Mivel a hardvermérnökök többsége szerint a HDL nem tekinthető programozási nyelvnek a hardver-refaktorálásra egy külön területként tekintünk.

Az analóg hardverleírások (VHDL-AMS-ben) automatikus refaktorálását Zeng és Huss javasolta.[20] Megközelítésük szerint a refaktorálás megőrzi a hardveres tervezés szimulált viselkedését. A nem funkcionális mérés az, hogy a refaktorált kód standard szintézises eszközökkel feldolgozható, az eredeti kód viszont nem. A digitális HDL-ek refaktorálását szintén a Synopsys munkatársa, Mike Keating vizsgálta.[21] [22] Célja, hogy a komplex rendszerek megértését könnyebbé tegye, ami növeli a tervezők produktivitását.

Története[szerkesztés]

Bár a refaktorálás informálisan évtizedek óta jelen volt, a szó (refactoring) legelőször 1990 szeptemberében jelent meg William Opdyke és Ralph Johnson cikkében.[23] Megjegyzendő, hogy a factoring és a factoring out kifejezéseket a Forth közösségben már az 1980-as évek eleje óta ilyen értelemben használták. Leo Brodie Thinking Forth (1984) könyvének hatodik fejezetét a témának szentelték.[24]

William Griswold 1991-es Ph.D. disszertációja az egyik elsõ nagyobb tudományos munka a funkcionális és a procedurális programok refaktorálásáról. Opdyke 1992-es disszertációja az objektumorientált programok refaktorálásáról szólt, bár az elmélet és a technika már régóta elérhető volt program transzformációs rendszerekként.[25] Mindezek az irományok áttekintést adnak a refaktorálás általános módszereiről.

Martin Fowler könyve, a Refactoring: Improving the Design of Existing Code referenciamunkának tekinthető.[26]

Automatizált kódrefaktorálás[szerkesztés]

Számos szerkesztőnek és fejlesztői környezetnek van automatikus refaktorálás-támogatása. Lehetséges az alkalmazáskód és a tesztkód refaktorálása is.[27] Alább néhány ilyen szerkesztő vagy úgynevezett refaktoráló böngésző:

Jegyzetek[szerkesztés]

  1. Kerievsky, Joshua. Refactoring to Patterns. Addison Wesley (2004) 
  2. Fowler, Martin. Refactoring. Improving the Design of Existing Code. Addison-Wesley, 63. o. (1999). ISBN 978-0-201-48567-7 
  3. Suryanarayana, Girish. Refactoring for Software Design Smells. Morgan Kaufmann, 258. o. (2014. november 1.). ISBN 978-0128013977 
  4. Martin, Robert. Clean Code. Prentice Hall (2009) 
  5. Haendler (2019. október 22.). „A Framework for the Assessment and Training of Software Refactoring Competences”. Proc. Of 11th International Conference on Knowledge Management and Information Systems (KMIS)..  
  6. Leiserson et al (2020). „There's plenty of room at the Top: What will drive computer performance after Moore's law?”. Science 368 (6495), eaam9744. o. DOI:10.1126/science.aam9744. PMID 32499413.  
  7. Nassif, Matthieu (2017. november 1.). „Revisiting turnover-induced knowledge loss in software projects”. 2017 IEEE International Conference on Software Maintenance and Evolution (ICSME), 261–272. o. DOI:10.1109/ICSME.2017.64.  
  8. van Gurp, Jilles (2002. március 1.). „Design erosion: problems and causes”. Journal of Systems and Software 61 (2), 105–119. o. DOI:10.1016/S0164-1212(01)00152-2.  
  9. Hassan (2010. november 1.). „Software intelligence: the future of mining software engineering data”. In Proceedings of the FSE/SDP Workshop on Future of Software Engineering Research (FoSER '10), 161–166. o. DOI:10.1145/1882362.1882397.  
  10. Novais, Renato (2017. október 22.). „Experimentally assessing the combination of multiple visualization strategies for software evolution analysis”. Journal of Systems and Software 128, 56–71. o. DOI:10.1016/j.jss.2017.03.006.  
  11. 1963-, Fowler, Martin. Refactoring : improving the design of existing code. Reading, MA: Addison-Wesley (1999. október 22.). ISBN 978-0201485677. OCLC 41017370 
  12. a b (these are only about OOP however).Refactoring techniques in Fowler's refactoring Website
  13. Java Power Tools (en nyelven). "O'Reilly Media, Inc.", 301. o. (2008. október 22.). ISBN 9781491954546. Hozzáférés ideje: 2018. július 26. 
  14. Refactoring techniques in Fowler's refactoring Website
  15. Ferrante (1987. július 1.). „The program dependence graph and its use in optimization”. ACM Transactions on Programming Languages and Systems 9 (3), 319–349. o, Kiadó: ACM. DOI:10.1145/24039.24041.  
  16. Donglin (2008. november 1.). „Slicing objects using system dependence graphs”. Proceedings. International Conference on Software Maintenance, 319–349. o, Kiadó: IEEE. DOI:10.1109/ICSM.1998.738527.  
  17. Replace type-checking code with State/Strategy
  18. Replace conditional with polymorphism
  19. Bruntink, Magiel, et al. "An evaluation of clone detection techniques for crosscutting concerns." Software Maintenance, 2004. Proceedings. 20th IEEE International Conference on. IEEE, 2004.
  20. Kaiping Zeng, Sorin A. Huss, "Architecture refinements by code refactoring of behavioral VHDL-AMS models". ISCAS 2006
  21. M. Keating :"Complexity, Abstraction, and the Challenges of Designing Complex Systems", in DAC'08 tutorial "Bridging a Verification Gap: C++ to RTL for Practical Design"
  22. M. Keating, P. Bricaud: Reuse Methodology Manual for System-on-a-Chip Designs, Kluwer Academic Publishers, 1999.
  23. Opdyke és Johnson (1990. szeptember 1.). „Refactoring: An Aid in Designing Application Frameworks and Evolving Object-Oriented Systems”., ACM. 
  24. Brodie, Leo. Thinking Forth, 171–196. o.. ISBN 0-9764587-0-5. Hozzáférés ideje: 2020. május 3.  Archiválva 2005. december 16-i dátummal a Wayback Machine-ben
  25. Opdyke, William F (June 1992), Refactoring Object-Oriented Frameworks, University of Illinois at Urbana-Champaign, <https://web.archive.org/web/20191216212919/https://dl.acm.org/citation.cfm?id=169783>. Hozzáférés ideje: 2008-02-12
  26. Fowler, Martin. Refactoring. Improving the Design of Existing Code. Addison-Wesley, 63ff. o. (1999). ISBN 978-0-201-48567-7 
  27. Xuan (2016). „B-Refactoring: Automatic test code refactoring to improve dynamic analysis”. Information and Software Technology 76, 65–80. o. DOI:10.1016/j.infsof.2016.04.016.  
  28. What's new in Xcode 9
  29. Refactoring in Qt Creator

További információk[szerkesztés]

Fordítás[szerkesztés]

Ez a szócikk részben vagy egészben a Code refactoring című angol Wikipédia-szócikk ezen változatának fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.