Dobre praktyki programowania

Hej, może zacznijmy ten post, zadaniem sobie pytania: czym są dobre praktyki programowania? Jakie korzyści one nam dają?

Generalnie to zbiór zasad, które mają na celu pomóc programistom tworzyć lepszy, bardziej czytelny, łatwiejszy w utrzymaniu i skalowalny kod. Praktyki te obejmują szereg technik i narzędzi, które pomagają programistom tworzyć aplikacje o wysokiej jakości i efektywnie wykorzystywać czas i zasoby.

DRY, KISS i YAGNI to trzy podstawowe zasady programowania, które pomagają programistom tworzyć lepsze, bardziej skalowalne i łatwiejsze w utrzymaniu oprogramowanie. Poniżej kilka przykładów użycia DRY, KISS i YAGNI:

DRY (Don’t Repeat Yourself) – Ta zasada mówi, że powinniśmy unikać powtarzania kodu w naszej aplikacji. Zamiast tego, powinniśmy tworzyć funkcje i klasy, które mogą być używane w wielu miejscach w naszym kodzie. Dzięki temu zmiany w kodzie są łatwiejsze do wprowadzenia, ponieważ musimy zmodyfikować tylko jeden fragment kodu zamiast wielu.

//z powtarzającym się kodem
function calculateAreaOfSquare($side) 
{
  $area = $side * $side;
  return $area;
}

function calculateAreaOfRectangle($length, $width) 
{
  $area = $length * $width;
  return $area;
}

//bez powtarzającego się kodu
function calculateArea($dimensions) 
{
  $area = 1;
  foreach($dimensions as $dimension) {
    $area *= $dimension;
  }
  return $area;
}

//Użycie
$areaOfSquare = calculateArea([4]);
$areaOfRectangle = calculateArea([4, 6]);

KISS (Keep It Simple, Stupid) – Ta zasada mówi, że powinniśmy tworzyć prosty kod, który jest łatwy do zrozumienia i utrzymania. Im prostszy kod, tym łatwiej jest go testować, debugować i wprowadzać zmiany.

// Zbyt skomplikowany kod
function generateRandomString($length) 
{
  $characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  $string = "";
  for ($i = 0; $i < $length; $i++) {
    $randomNumber = mt_rand(0, strlen($characters)-1);
    $string .= $characters[$randomNumber];
  }
  return $string;
}

//Prostszy kod
function generateRandomString($length) 
{
  return bin2hex(random_bytes($length));
}

YAGNI (You Ain’t Gonna Need It) to zasada, która mówi, że nie należy dodawać funkcjonalności do kodu, jeśli nie jest ona niezbędna. Oznacza to, że programiści powinni tworzyć tylko tyle kodu, ile jest potrzebne, a nie tworzyć kodu na zapas, który może nigdy nie być użyty.

Przykładem w PHP dla YAGNI może być sytuacja, w której programista przewiduje, że aplikacja będzie potrzebowała w przyszłości funkcjonalności do obsługi płatności. Może się zdarzyć, że programista będzie chciał dodać do kodu funkcję do obsługi płatności, zanim będzie to konieczne. Jednak zgodnie z zasadą YAGNI, nie powinien tego robić, dopóki nie będzie pewny, że taka funkcjonalność jest potrzebna.

Innym przykładem może być sytuacja, w której programista przewiduje, że będzie potrzebował kilku różnych klas do obsługi różnych typów danych. Może być skłonny do napisania kodu dla tych klas, zanim będzie potrzebował ich w swojej aplikacji. Zgodnie z zasadą YAGNI, nie powinien tego robić, dopóki nie będzie pewny, że takie klasy są niezbędne do realizacji funkcjonalności aplikacji.

W obu przypadkach programista powinien skupić się na napisaniu tylko tyle kodu, ile jest potrzebne do realizacji bieżących wymagań aplikacji, a nie tworzyć kodu na zapas, który może nigdy nie być użyty.

Oprócz DRY, KISS i YAGNI istnieje wiele innych dobrych praktyk programistycznych, które pomagają tworzyć dobre oprogramowanie. Postaram sie poniżej zebrać te najważniejsze:

SOLID (przeczytaj o SOLID w moim osobnym artykule) – SOLID to skrót od pięciu zasad projektowania oprogramowania: Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle i Dependency Inversion Principle. Te zasady pomagają programistom tworzyć elastyczny, łatwy do utrzymania kod, który jest bardziej odporny na zmiany.
Test Driven Development (TDD) – TDD to praktyka polegająca na pisaniu testów jednostkowych przed napisaniem kodu aplikacji. Testy te mają pomóc programistom upewnić się, że ich kod działa zgodnie z oczekiwaniami. TDD pomaga uniknąć błędów i zapewnia, że kod jest łatwy do testowania.
Continuous Integration/Continuous Deployment (CI/CD) – CI/CD to praktyka polegająca na częstym i automatycznym dostarczaniu kodu do produkcji. CI/CD pomaga programistom zapewnić, że ich kod działa zgodnie z oczekiwaniami i że nie powoduje problemów w produkcji.
Code Reviews – Przegląd kodu przez innego programistę jest dobrym sposobem na wykrywanie błędów i unikanie złych praktyk programistycznych. Code reviews pomagają również zapewnić, że kod jest łatwy do zrozumienia i utrzymania.
Version Control – Korzystanie z systemów kontroli wersji, takich jak Git, pozwala programistom na śledzenie zmian w kodzie i łatwe cofanie się do wcześniejszych wersji. Systemy kontroli wersji pomagają również w pracy zespołowej, umożliwiając programistom pracę nad tym samym kodem równocześnie.
Clean Code – Praktykowanie „czystego kodu” to podejście do pisania kodu, które skupia się na tworzeniu czytelnego, zrozumiałego i łatwego do utrzymania kodu. Czysty kod powinien być łatwy do czytania i zmieniania przez innych programistów, co ułatwia rozwijanie i utrzymanie aplikacji.
Refaktoryzacja – Refaktoryzacja to proces wprowadzania zmian w kodzie, które poprawiają jego jakość, ale nie zmieniają jego zachowania. Refaktoryzacja może polegać na usunięciu powtarzającego się kodu, poprawie nazw zmiennych i funkcji czy zmianie struktury kodu, aby był bardziej zrozumiały. Refaktoryzacja pomaga utrzymać kod w dobrej kondycji i łatwiejszym do utrzymania.
Wpięcie testów statycznych – Testy statyczne wykorzystują specjalne narzędzia, takie jak analizatory kodu źródłowego, które przeglądają kod i wskazują potencjalne problemy, takie jak błędy składni, niespójności w nazewnictwie, niezainicjowane zmienne, nadużycie pamięci, zbyt złożone instrukcje warunkowe, brak obsługi wyjątków itp. Testy statyczne pozwalają programistom na wykrycie błędów i problemy zanim kod zostanie skompilowany i uruchomiony, co przyczynia się do szybszego i bardziej efektywnego procesu testowania i debugowania.