Software engineering

Refaktoryzacja to takie słowo, które zabija rozmowę gdy wypowiesz je wśród znajomych, którzy nie są programistami, a to przecież nic innego jak proces poprawiania struktury kodu źródłowego bez zmieniania jego funkcjonalności. Jest to ważny element w procesie tworzenia oprogramowania, ponieważ pozwala na utrzymanie czystego kodu w dobrym stanie technicznym i ułatwia jego późniejsze rozwijanie.

Podczas refaktoryzacji:

• usuwasz zbędny kod

• upraszczasz skomplikowane struktury

• poprawiasz czytelność kodu

• zwiększasz jego przejrzystość.

Wszystko po to, by kod był łatwiejszy w utrzymaniu i mniej podatny na błędy.

Co ważne — refaktoryzacja nie polega na dodawaniu nowych funkcjonalności, tylko na usprawnianiu istniejącego kodu. Dzięki temu, że kod jest lepiej zorganizowany, łatwiej jest wprowadzać zmiany, a także wychwytywać błędy, co przekłada się na jakość ogólną jakość kodu.

Plusy refaktoryzacji

• Utrzymywanie kodu w dobrym stanie technicznym

• Ułatwienie późniejszego rozwijania oprogramowania

• Usuwanie zbędnego kodu

• Uproszczenie skomplikowanych struktur

• Poprawa czytelności kodu

• Zwiększenie jego przejrzystości

• Łatwiejsze wprowadzanie zmian

• Wychwytywanie błędów, co przekłada się na jakość całego oprogramowania

Jaki jest oczekiwany wynik refaktoryzacji kodu?

Efektem refaktoryzacji jest kod w lepszym stanie niż był przed. Przekłada się to na łatwiejsze wprowadzanie zmian w przyszłosci, a także wychwytywanie błędów, co przekłada się na jakość całego oprogramowania.

Dzięki refaktoryzacji poprawia się tez czytelność kodu oraz łatwiej go zrozumieć. Często też wynikiem refaktoringu jest usunięcie dużej ilości zbędnego kodu.

Jakie problemy można napotkać podczas refaktoryzacji?

Podczas refaktoryzacji kodu możesz napotkać wiele różnych problemów. Jednym z najczęstszych jest ryzyko wprowadzenia nowych błędów przy zmienianiu kodu. Innym problemem może być konieczność przeprowadzenia dodatkowych testów, aby upewnić się, że zmiany nie wpłynęły na funkcjonalność oprogramowania. Refaktoryzacja może również zająć dużo czasu i zasobów, zwłaszcza przy większych projektach.

Czasochłonność

Refaktoryzacja kodu jest procesem, który ma na celu poprawę jakości kodu poprzez wprowadzenie zmian, które zwiększą czytelność, zrozumiałość i łatwość utrzymania. Jest to proces, który może zająć dużo czasu i zasobów, szczególnie przy większych projektach. Dlatego ważne jest, aby przeprowadzić tę refaktoryzację kodu w sposób ostrożny i bez szaleństw. W tym celu, można rozważyć stworzenie planu refaktoryzacji, który będzie uwzględniał priorytetyzowanie obszarów kodu, które wymagają najwięcej uwagi oraz zapewnienie, że proces refaktoringu jest stopniowy i kontrolowany.

Możliwość zepsucia czegoś co dobrze działało

Istnieje ryzyko wprowadzenia nowych błędów przy zmianie kodu. Dlatego ważne jest, aby każda zmiana była dokładnie przetestowana. Idealnie jak kod jest pokryty testami automatycznymi. Refaktoryzacja to tez dobry czas na dodanie brakujących testów. Ponadto, oprócz testowania, ważne jest, aby kod był starannie dokumentowany, co ułatwi zrozumienie go przez innych członków zespołu w przyszłości. Zadbaj też o to, aby kod był pisany w sposób czytelny i przejrzysty, co ułatwi jego dalszą rozbudowę i utrzymanie w przyszłości.

Konieczność wnikliwego testowania

Każda zmiana kodu niesie ze sobą pewne ryzyko wprowadzenia nowych błędów. Aby zmniejszyć to ryzyko, konieczne jest przeprowadzenie dokładnych testów po każdej zmianie, zwłaszcza jeśli polega ona na wprowadzeniu nowych funkcjonalności lub modyfikacji istniejącego kodu.

Jest to niesamowicie trudne, gdy bazujesz na manualnych testach regresji. Wtedy ryzyko jest największe dlatego musisz być bardzo ostrożny.

Podczas refaktoringu warto regularnie dokonywać przeglądów kodu przez innych programistów, co pozwoli na szybkie wykrycie błędów oraz podniesienie jakości kodu. Ostatecznie, należy pamiętać, że wprowadzanie zmian do kodu to nie tylko ryzyko, ale również szansa na poprawę jego jakości i funkcjonalności. Dlatego też, warto podejść do tego procesu z odpowiednią dbałością i zrozumieniem, że każda zmiana jest potencjalną okazją do rozwoju i usprawnienia projektu.

Refaktoryzacja kodu może wymagać dodatkowych testów, aby upewnić się, że zmiany nie wpłynęły negatywnie na funkcjonalność oprogramowania natomiast jest to ryzyko, które często warto podjąć w celu poprawy jakości projektu.

Koszty

Refaktoryzacja, czyli proces poprawy jakości kodu, może być dość kosztowna i wymagać dużych nakładów pracy, zwłaszcza w przypadku większych projektów. Warto jednak zainwestować w tę czynność, ponieważ przynosi ona wiele korzyści.

Poprawa jakości kodu znacznie ułatwia dalszy rozwój projektu, zwiększa jego stabilność i niezawodność, a także ułatwia pracę nad nim w przyszłości. Ponadto, refaktoryzacja pozwala na bardziej efektywne wykorzystanie zasobów oraz zwiększa czytelność kodu, co ułatwia pracę programistom i przyspiesza proces wdrażania nowych funkcji i funkcjonalności.

W związku z tym, warto poświęcić czas i zasoby na refaktoryzację programu, aby osiągnąć lepszą jakość kodu oraz usprawnić procesy związane z rozwojem projektu.

Koszt refaktoryzacji zależy od wielu czynników, takich jak rozmiar projektu, stopień skomplikowania kodu, liczba programistów pracujących nad projektem i wiele innych.

Ryzyko

Refaktoryzacja kodu, czyli przeprowadzenie szeregu zmian w kodzie źródłowym, może być skomplikowaną i czasochłonną procedurą wymagającą wiedzy i doświadczenia. Bez odpowiedniego przygotowania i umiejętności, taka zmiana może zwiększyć ryzyko wystąpienia błędów, co prowadziłoby do skutków ubocznych, takich jak spadki wydajności lub nieprawidłowe działanie aplikacji. W związku z tym, ważne jest aby w zespole byli doświadczeni programiści, którzy mogą dokonywać refaktoryzacji albo być mentorami dla mniej doświadczonych kolegów.

5 sygnałów wskazujących na to, że aplikacja wymaga refaktoryzacji

Kiedy kod staje się trudny do zrozumienia, modyfikowania lub testowania, jest to sygnał, że może świadczyć o konieczności przeprowadzenia refaktoryzacji. Gdy wprowadzanie zmian do systemu (nawet najprostszych) jest koszmarem, być może jest to ostatni dzwonek aby robić refaktoryzację. Z pewnością jako dobry programista często zauważysz konieczność przeprowadzenia refaktoryzacji kodu.

Zespoły, które nie robią refaktoryzacji szybko się rozpadają bo w realiach naszej branży programista może zmieniać pracę jak rękawiczki i gdy codzienna praca z kodem jest przytłaczająca, a nie ma przestrzeni na poprawę to zmiana pracy jest prosta i skuteczną opcją.

Jeśli kod jest napisany w sposób niespójny lub mało intuicyjny, trudno będzie nowym programistom zrozumieć jego działanie. Wiąże się to z tym, że ciężko znaleźć programistów do zespołów, które utrzymują jakiś bardzo śmierdzący kod, który wyciska łzy od samego patrzenia.

Kod jest trudny do zrozumienia, modyfikowania lub testowania

Właściwe zrozumienie kodu może pomóc w uniknięciu błędów i usprawnieniu pracy. Współpraca z innymi programistami może również pomóc w zrozumieniu kodu i w ulepszaniu go w sposób, który oszczędza czas i zwiększa wydajność.

Czasami jednak kod jest tak napisany, że nie da się go zrozumieć. Brak testów, brak dokumentacji, a programisty, który go pisał już pracuje w innej firmie. To jasny sygnał, że czas ten kod przepisać.

Kod jest napisany w sposób niespójny lub mało intuicyjny

Niespójny kod jest ciężki do zrozumienia. Nawet najmniejszy fragment kodu może być trudny do zrozumienia dla innych. W celu poprawy jego czytelności, należy przemyśleć jego strukturę, zadbać o spójną konwencję nazewnictwa, lepszą czytelność kodu i zastosować bardziej intuicyjną składnię. Można również rozważyć dodanie komentarzy, aby ułatwić innym programistom zrozumienie jego działania. W ten sposób można zwiększyć jego dostępność i umożliwić innym osobom pracę nad projektem w przyszłości.

Kod zawiera powtarzające się fragmenty

Kod, który powtarza te same fragmenty, może utrudnić utrzymanie kodu w przyszłości. W takim przypadku, gdy istniejący kod zawiera powtarzające się fragmenty, warto rozważyć użycie funkcji lub zmiennych, które pomogą zminimalizować duplikację kodu i ułatwią jego rozwój w przyszłości.

Kod powoduje problemy w przypadku wprowadzenia zmian

Gdy wprowadzasz zmiany w jednym miejscu, a aplikacja wybucha w innym — jest to wystarczająco dobry powód, żeby rozpocząć refaktoring i proces pozbycia się długu technologicznego. Ważne jest, aby programiści znali dokładnie kod, który tworzą i byli w stanie go skutecznie modyfikować. W ten sposób można uniknąć wystąpienia błędów i zapewnić, że aplikacja działa poprawnie i bez zakłóceń.

Techniki refaktoryzacji

Martin Fowler w swojej książce “Refaktoryzacja” opisuje wiele znakomitych technik refaktoryzacji. Pozwól, że pokażę Ci tutaj kilka z nich.

Ekstrakcja funkcji

Ekstrakcja funkcji to technika refaktoryzacji, która polega na wyodrębnieniu określonej części kodu z metody i umieszczeniu jej w osobnej metodzie. Bardzo lubię tą technikę ponieważ pozwala na wydzielenie jakiegoś kodu do funkcji (może być to nawet jakieś dwie linie kodu) i nazwanie tego kodu poprzez nazwanie funkcji. Dzięki temu poprawiamy czytelność i sprawiamy, że kod może być użyty też w innym miejscu dzięki funkcji.

Przykład:

Przed refaktoryzacją:

function calculateOrderTotal(price, tax_rate, discount) {
    const taxAmount = price * tax_rate
    const discountAmount = price * discount
    const totalAmount = price + taxAmount - discountAmount

    return totalAmount
}

Po refaktoryzacji:

function calculateOrderTotal(price, taxRate, discount) {
    const taxAmount = calculateTax(price, taxRate)
    const discountAmount = calculateDiscount(price, discount)
    const totalAmount = price + taxAmount - discountAmount

    return totalAmount
}

function calculateTax(price, taxRate) {
    return price * taxRate
}

function calculateDiscount(price, discount) {
    return price * discount
}

Wchłonięcie funkcji

Wchłonięcie funkcji to technika refaktoryzacji, która polega na zastąpieniu wywołania funkcji kodem, który znajduje się w ciele samej funkcji. Często jest to wykorzystywane w przypadku, gdy dana funkcja jest wywoływana tylko w jednym miejscu w kodzie i nie jest już nigdzie indziej używana. Dzięki wchłonięciu funkcji kod staje się bardziej czytelny i łatwiejszy do zrozumienia.

Przykład:

function calculateSum(a, b) {
    return a + b;
}

function calculateDifference(a, b) {
    return a - b;
}

function calculate(a, b) {
    console.log(calculateSum(a, b));
    console.log(calculateDifference(a, b))
}

W tym przypadku możesz zastosować wchłonięcie funkcji i zastąpić wywołania funkcji kodem znajdującym się w ciele funkcji calculate:

function calculate(a, b) {
    console.log(a + b);
    console.log(a -b)
}

Dzięki temu kod jest bardziej czytelny i łatwiejszy do zrozumienia, a w przypadku zmian w kodzie nie trzeba zmieniać wielu funkcji, tylko jedną.

Zebranie funkcji w klasę

Zebranie funkcji w klasę to technika refaktoryzacji, która polega na umieszczeniu funkcji wewnątrz klasy. Dzięki temu kod może być bardziej czytelny, łatwiejszy do zarządzania i bardziej modularny.

Przykład:

Przed refaktoryzacją:

function calculateSum(a, b) {
    return a + b;
}

function calculateDifference(a, b) {
    return a - b;
}

Po refaktoryzacji:

class Calculator {
    calculateSum(a, b) {
        return a + b;
    }

    calculateDifference(a, b) {
        return a - b;
    }
}

Dzięki zebraniu funkcji w klasę, możesz łatwiej zarządzać kodem i uniknąć problemów z zasięgiem zmiennych. Ponadto, kod może być łatwiejszy do testowania i debugowania, a zmiany mogą być łatwiejsze do wprowadzenia w przyszłości.

Podział pętli

Podział pętli to technika refaktoryzacji polegająca na podzieleniu istniejącej pętli na dwie lub więcej pętli, aby ułatwić zrozumienie kodu i zwiększyć jego czytelność. Może to być przydatne w przypadku, gdy pętla wykonuje kilka zadań jednocześnie lub ma zbyt wiele warunków.

Przed refaktoryzacją:

let averageAge = 0;
let totalSalary = 0;

for (const person of people) {
    averageAge += person.age;
    totalSalary += person.salary
}

averageAge = averageAge / people.length

Po refaktoryzacji:

let totalSalary = 0;
for (const person of people) {
    totalSalary += person.salary
}

let averageAge = 0;
for (const person of people) {
    averageAge += person.age;
}

averageAge = averageAge / people.length

W tym przypadku, pierwotna pętla została podzielona na dwie pętle: jedną, która wlicza całkowite zarobki i drugą, która wylicza średni wiek . Dzięki temu kod jest bardziej czytelny i łatwiejszy do zrozumienia, a wszelkie zmiany mogą być łatwiejsze do wprowadzenia w przyszłości.

Podsumowanie

Refaktoryzacja to proces poprawiania struktury kodu źródłowego, który nie zmienia jego funkcjonalności. Usuwa się zbędny kod, upraszcza skomplikowane struktury i zwiększa przejrzystość kodu. Jest to niezbędne w procesie tworzenia oprogramowania, ponieważ pozwala na utrzymanie kodu w dobrym stanie technicznym i ułatwia jego rozwijanie. W niniejszym artykule pokazałem Ci techniki refaktoryzacji, sygnały potrzeby refaktoryzacji i plusy i minusy tego procesu.

Jeśli chcesz się zagłębić w temat refaktoryzacji kodu to polecam te książki:

• “Refaktoryzacja” Martina Fowlera

• “Czysty kod” Roberta C. Martina

• “Kod doskonały” Steve’a McConnella