Czysty kod. Receptury. Przepisy na poprawienie struktury i jakości Twojego kodu - ebook

Funkcjonalność oprogramowania nieustannie się poszerza, a nowoczesny kod jest coraz częściej generowany przez narzędzia oparte na sztucznej inteligencji. W tych warunkach czystość kodu staje się niezwykle ważna. Niezależnie od tego, czy pracujesz na oprogramowaniu zastrzeżonym, czy otwartym, czysty kod jest najlepszym sposobem na to, aby zachować świeżość projektów i ich gotowość do rozwoju.

Oto książka wsparta głęboką teorią i wieloma praktycznymi przykładami pisania czystego kodu!

Daniel Moka, inżynier oprogramowania, Moka IT

Receptury zawarte w tym zbiorze pozwalają nie tylko zrozumieć koncepcję czystego kodu, ale również poznać zasady identyfikacji kodu wymagającego poprawy i oceny wpływu refaktoryzacji na kod produkcyjny. Poza recepturami opisano tu potrzebne narzędzia i przedstawiono wskazówki dotyczące technik zmieniania kodu ... wraz z licznymi przykładami. Omówiono ponadto różne praktyki, heurystyki i reguły projektowania oprogramowania w sposób zapewniający jego niezawodność, łatwość testowania, bezpieczeństwo i skalowalność. Docenisz, że przykłady kodu zostały przedstawione w kilku nowoczesnych językach programowania. Dzięki temu receptury zawarte w tym przewodniku są przydatne niezależnie od używanego języka.

W książce:

• znaczenie czystego kodu i identyfikacja możliwości jego poprawy
• techniki refaktoryzacji
• zestaw przykładów w kilku współczesnych językach programowania
• brzydkie zapachy kodu, ich konsekwencje i potencjalne rozwiązania
• techniki pisania prostego, czytelnego kodu

W tej książce doskonale uchwycono głęboką wiedzę o tworzeniu oprogramowania!

Alex Bunardzic, deweloper i instruktor

Słowo wstępne

Przedmowa

1. Czysty kod

• 1.1. Czym jest brzydki zapach kodu?
• 1.2. Co to jest refaktoryzacja?
• 1.3. Co to jest receptura?
• 1.4. Po co czysty kod?
• 1.5. Czytelność, wydajność czy jedno i drugie
• 1.6. Typy oprogramowania
• 1.7. Kod generowany maszynowo
• 1.8. Kwestie nazewnicze
• 1.9. Wzorce projektowe
• 1.10. Paradygmaty języków oprogramowania
• 1.11. Obiekty kontra klasy
• 1.12. Łatwość wprowadzania zmian

2. Aksjomaty

• 2.0. Wprowadzenie
• 2.1. Dlaczego model?
• 2.2. Dlaczego abstrakcyjne?
• 2.3. Dlaczego programowalne?
• 2.4. Dlaczego częściowe?
• 2.5. Dlaczego wyjaśnienie?
• 2.6. Dlaczego rzeczywistości?
• 2.7. Wyprowadzanie reguł
• 2.8. Jedna i jedyna zasada projektowania oprogramowania

3. Modele anemiczne

• 3.0. Wprowadzenie
• 3.1. Przekształcanie obiektów anemicznych we wzbogacone
• 3.2. Identyfikowanie istoty obiektów
• 3.3. Usuwanie metod ustawiających
• 3.4. Usuwanie generatorów anemicznego kodu
• 3.5. Usuwanie właściwości automatycznych
• 3.6. Usuwanie obiektów DTO
• 3.7. Uzupełnianie pustych konstruktorów
• 3.8. Usuwanie metod pobierających
• 3.9. Zapobieganie orgiom obiektów
• 3.10. Usuwanie właściwości dynamicznych

4. Obsesja na punkcie prymitywów

• 4.0. Wprowadzenie
• 4.1. Tworzenie małych obiektów
• 4.2. Reifikacja danych prymitywnych
• 4.3. Reifikacja tablic asocjacyjnych
• 4.4. Usuwanie nadużyć łańcuchów
• 4.5. Reifikacja znaczników czasowych
• 4.6. Reifikacja podzbiorów jako obiektów
• 4.7. Reifikacja walidacji łańcuchów
• 4.8. Usuwanie niepotrzebnych właściwości
• 4.9. Tworzenie interwałów dat

5. Mutowalność

• 5.0. Wprowadzenie
• 5.1. Zmienianie deklaracji var na const
• 5.2. Deklarowanie zmiennych jako zmiennych
• 5.3. Zabranianie zmian istoty
• 5.4. Unikanie mutowalnych tablic stałych
• 5.5. Usuwanie leniwej inicjalizacji
• 5.6. Zamrażanie mutowalnych stałych
• 5.7. Usuwanie skutków ubocznych
• 5.8. Zapobieganie windowaniu

6. Kod deklaratywny

• 6.0. Wprowadzenie
• 6.1. Zawężanie wielokrotnie wykorzystywanych zmiennych
• 6.2. Usuwanie pustych wierszy
• 6.3. Usuwanie wersjonowanych metod
• 6.4. Usuwanie podwójnych zaprzeczeń
• 6.5. Zmienianie źle przypisanych obowiązków
• 6.6. Zastępowanie jawnych iteracji
• 6.7. Dokumentowanie decyzji projektowych
• 6.8. Zastępowanie magicznych liczb stałymi
• 6.9. Oddzielanie "co" od "jak"
• 6.10. Dokumentowanie wyrażeń regularnych
• 6.11. Przekształcanie warunków Yody
• 6.12. Usuwanie dowcipnych metod
• 6.13. Unikanie piekła wywołań zwrotnych
• 6.14. Generowanie dobrych komunikatów o błędach
• 6.15. Unikanie magicznych poprawek

7. Nazewnictwo

• 7.0. Wprowadzenie
• 7.1. Rozwijanie skrótów
• 7.2. Zmienianie nazw oraz dzielenie klas pomocniczych i narzędziowych
• 7.3. Zmienianie nazw MoichObiektów
• 7.4. Zmienianie nazw zmiennych wynikowych
• 7.5. Zmienianie nazw pochodzących od typów
• 7.6. Zmienianie długich nazw
• 7.7. Zmienianie abstrakcyjnych nazw
• 7.8. Poprawianie pomyłek w pisowni
• 7.9. Usuwanie nazw klas z atrybutów
• 7.10. Usuwanie pierwszej litery z nazw klas i interfejsów
• 7.11. Zmienianie nazw funkcji zawierających słowa Basic/Do
• 7.12. Przekształcanie nazw klas w liczbie mnogiej w liczbę pojedynczą
• 7.13. Usuwanie z nazw słowa "Collection"
• 7.14. Usuwanie z nazw klas przedrostka/przyrostka "Impl"
• 7.15. Zmienianie nazw argumentów według roli
• 7.16. Usuwanie redundantnych nazw parametrów
• 7.17. Usuwanie z nazw bezcelowego kontekstu
• 7.18. Unikanie nazywania obiektów "danymi"

8. Komentarze

• 8.0. Wprowadzenie
• 8.1. Usuwanie "wykomentowanego" kodu
• 8.2. Usuwanie przestarzałych komentarzy
• 8.3. Usuwanie komentarzy logicznych
• 8.4. Usuwanie komentarzy do metod pobierających
• 8.5. Przekształcanie komentarzy w nazwy funkcji
• 8.6. Usuwanie komentarzy wewnątrz metod
• 8.7. Zastępowanie komentarzy testami

9. Standardy

• 9.0. Wprowadzenie
• 9.1. Przestrzeganie standardów kodu
• 9.2. Standaryzowanie wcięć
• 9.3. Unifikowanie wielkości liter
• 9.4. Pisanie kodu po angielsku
• 9.5. Unifikowanie kolejności parametrów
• 9.6. Naprawianie wybitych szyb

10. Złożoność

• 10.0. Wprowadzenie
• 10.1. Usuwanie powtarzalnego kodu
• 10.2. Usuwanie ustawień/konfiguracji i przełączników funkcji
• 10.3. Zmienianie stanu jako właściwości
• 10.4. Usuwanie z kodu pomysłowości
• 10.5. Łączenie wielu obietnic
• 10.6. Przerywanie długich łańcuchów współpracy
• 10.7. Wyodrębnianie metody do obiektu
• 10.8. Dbanie o konstruktory tablic
• 10.9. Usuwanie poltergeistów

11. Rozdęcie

• 11.0. Wprowadzenie
• 11.1. Dzielenie zbyt długich metod
• 11.2. Ograniczanie nadmiaru argumentów
• 11.3. Ograniczanie nadmiaru zmiennych
• 11.4. Usuwanie nadmiaru nawiasów
• 11.5. Usuwanie nadmiaru metod
• 11.6. Dzielenie zbyt licznych atrybutów
• 11.7. Ograniczanie list importu
• 11.8. Dzielenie funkcji wielozadaniowych
• 11.9. Dzielenie grubych interfejsów

12. YAGNI

• 12.0. Wprowadzenie
• 12.1. Usuwanie martwego kodu
• 12.2. Używanie kodu zamiast diagramów
• 12.3. Refaktoryzowanie klas z jedną podklasą
• 12.4. Usuwanie interfejsów jednorazowych
• 12.5. Usuwanie nadużyć wzorców projektowych
• 12.6. Zastępowanie kolekcji biznesowych

13. Szybkie reagowanie na błędy

• 13.0. Wprowadzenie
• 13.1. Refaktoryzowanie ponownego przypisywania zmiennych
• 13.2. Egzekwowanie warunków wstępnych
• 13.3. Używanie bardziej rygorystycznych parametrów
• 13.4. Usuwanie wartości domyślnej z instrukcji switch
• 13.5. Unikanie modyfikowania kolekcji podczas ich przetwarzania
• 13.6. Redefiniowanie haszowania i równości
• 13.7. Refaktoryzacja bez zmian funkcjonalnych

14. Instrukcje if

• 14.0. Wprowadzenie
• 14.1. Zastępowanie akcydentalnych instrukcji if polimorfizmem
• 14.2. Zmienianie nazw zmiennych sygnalizujących zdarzenia
• 14.3. Reifikacja zmiennych logicznych
• 14.4. Zastępowanie instrukcji switch/case/elseif
• 14.5. Zastępowanie zakodowanych "na sztywno" warunków if kolekcjami
• 14.6. Zmienianie warunków logicznych na zwarciowe
• 14.7. Dodawanie niejawnego warunku else
• 14.8. Poprawianie warunkowego kodu strzałkowego
• 14.9. Unikanie hakerskich zwarć
• 14.10. Poprawianie zagnieżdżonego kodu strzałkowego
• 14.11. Zapobieganie zwracaniu wartości logicznych podczas sprawdzania warunków
• 14.12. Zmienianie porównań z wartościami logicznymi
• 14.13. Wyodrębnianie kodu z długich warunków trójargumentowych
• 14.14. Przekształcanie funkcji niepolimorficznych w polimorficzne
• 14.15. Zmienianie sprawdzania równości
• 14.16. Reifikacja zakodowanych "na sztywno" warunków biznesowych
• 14.17. Usuwanie nieuzasadnionych wartości logicznych
• 14.18. Poprawianie zagnieżdżonych warunków trójargumentowych

15. Null

• 15.0. Wprowadzenie
• 15.1. Tworzenie obiektów null
• 15.2. Usuwanie opcjonalnego dostępu łańcuchowego
• 15.3. Przekształcanie opcjonalnych atrybutów w kolekcję
• 15.4. Używanie prawdziwych obiektów do reprezentowania wartości null
• 15.5. Reprezentowanie nieznanych lokacji bez użycia null

16. Przedwczesna optymalizacja

• 16.0. Wprowadzenie
• 16.1. Unikanie identyfikatorów w obiektach
• 16.2. Usuwanie przedwczesnej optymalizacji
• 16.3. Usuwanie przedwczesnej optymalizacji w postaci operacji bitowych
• 16.4. Ograniczanie nadmiernej generalizacji
• 16.5. Zmienianie optymalizacji strukturalnych
• 16.6. Usuwanie zakotwiczonych łodzi
• 16.7. Wyodrębnianie pamięci podręcznych z obiektów dziedzinowych
• 16.8. Usuwanie zdarzeń opartych na implementacji
• 16.9. Usuwanie kwerend z konstruktorów
• 16.10. Usuwanie kodu z destruktorów

17. Sprzężenie

• 17.0. Wprowadzenie
• 17.1. Ujawnianie ukrytych założeń
• 17.2. Zastępowanie singletonów
• 17.3. Rozbijanie boskich obiektów
• 17.4. Rozdzielanie rozbieżnych zmian
• 17.5. Przekształcanie specjalnych flag typu 9999 w normalne wartości
• 17.6. Usuwanie chirurgii strzelbowej
• 17.7. Usuwanie argumentów opcjonalnych
• 17.8. Zapobieganie zawiści funkcjonalnej
• 17.9. Usuwanie pośrednika
• 17.10. Przenoszenie argumentów domyślnych na koniec
• 17.11. Unikanie efektu domina
• 17.12. Usuwanie akcydentalnych metod z obiektów biznesowych
• 17.13. Usuwanie kodu biznesowego z interfejsu użytkownika
• 17.14. Zmienianie sprzężenia z klasami
• 17.15. Refaktoryzacja zbitek danych
• 17.16. Przerywanie niestosownej bliskości
• 17.17. Przekształcanie obiektów wymiennych

18. Globalność

• 18.0. Wprowadzenie
• 18.1. Reifikacja funkcji globalnych
• 18.2. Reifikacja funkcji statycznych
• 18.3. Zastępowanie instrukcji goto ustrukturyzowanym kodem
• 18.4. Usuwanie klas globalnych
• 18.5. Zmienianie globalnego tworzenia dat

19. Hierarchie

• 19.0. Wprowadzenie
• 19.1. Eliminowanie głębokiego dziedziczenia
• 19.2. Rozbijanie hierarchii jojo
• 19.3. Eliminowanie subklasyfikacji stosowanej w celu wielokrotnego wykorzystywania kodu
• 19.4. Zastępowanie relacji "jest" działaniem
• 19.5. Usuwanie zagnieżdżonych klas
• 19.6. Zmienianie nazw izolowanych klas
• 19.7. Oznaczanie klas konkretnych jako finalnych
• 19.8. Jawne definiowanie dziedziczenia klas
• 19.9. Migrowanie pustych klas
• 19.10. Opóźnianie przedwczesnej optymalizacji
• 19.11. Usuwanie atrybutów chronionych
• 19.12. Uzupełnianie pustych implementacji

20. Testowanie

• 20.0. Wprowadzenie
• 20.1. Testowanie metod prywatnych
• 20.2. Dodawanie opisów do asercji
• 20.3. Migrowanie assertTrue do konkretnych asercji
• 20.4. Zastępowanie atrap prawdziwymi obiektami
• 20.5. Dopracowywanie ogólnikowych asercji
• 20.6. Usuwanie niestabilnych testów
• 20.7. Zmienianie asercji z liczbami zmiennoprzecinkowymi
• 20.8. Zmienianie danych testowych w dane realistyczne
• 20.9. Eliminowanie testów naruszających enkapsulację
• 20.10. Usuwanie nieistotnych informacji testowych
• 20.11. Dodawanie pokrycia testowego do każdego wniosku o scalenie
• 20.12. Poprawianie testów zależnych od dat
• 20.13. Nauka nowego języka programowania

21. Dług techniczny

• 21.0. Wprowadzenie
• 21.1. Usuwanie kodu zależnego od środowiska produkcyjnego
• 21.2. Usuwanie list znanych defektów
• 21.3. Włączanie ostrzeżeń/ rygorystycznej kontroli błędów
• 21.4. Unikanie i usuwanie rzeczy "do zrobienia" i "do poprawki"

22. Wyjątki

• 22.0. Wprowadzenie
• 22.1. Usuwanie pustych bloków wyjątków
• 22.2. Usuwanie niepotrzebnych wyjątków
• 22.3. Poprawianie wyjątków obsługujących oczekiwane przypadki
• 22.4. Poprawianie zagnieżdżonych instrukcji try/catch
• 22.5. Zastępowanie kodów zwrotnych wyjątkami
• 22.6. Poprawianie kodu strzałkowego do obsługi wyjątków
• 22.7. Ukrywanie niskopoziomowych błędów przed użytkownikami końcowymi
• 22.8. Zawężanie bloków try w wyjątkach

23. Metaprogramowanie

• 23.0. Wprowadzenie
• 23.1. Usuwanie użycia metaprogramowania
• 23.2. Reifikacja funkcji anonimowych
• 23.3. Usuwanie preprocesorów
• 23.4. Usuwanie metod dynamicznych

24. Typy

• 24.0. Wprowadzenie
• 24.1. Usuwanie sprawdzania typów
• 24.2. Radzenie sobie z wartościami pseudoprawdziwymi
• 24.3. Zmienianie liczb zmiennoprzecinkowych w dziesiętne

25. Bezpieczeństwo

• 25.0. Wprowadzenie
• 25.1. Sanityzacja danych wejściowych
• 25.2. Zmienianie sekwencyjnych identyfikatorów
• 25.3. Usuwanie zależności od pakietów
• 25.4. Zastępowanie szkodliwych wyrażeń regularnych
• 25.5. Ochrona deserializacji obiektu

Słownik terminów