Details zum E-Book

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

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

Maximiliano Contieri

E-book

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

  • Titel: Czysty kod. Receptury. Przepisy na poprawienie struktury i jakości Twojego kodu
  • Autor: Maximiliano Contieri
  • Originaler Titel: Clean Code Cookbook: Recipes to Improve the Design and Quality of Your Code
  • Übersetzung: Grzegorz Werner
  • ISBN: 978-83-289-1422-3, 9788328914223
  • Veröffentlichungsdatum: 2024-09-24
  • Format: E-book
  • Artikelkennung: czykor
  • Verleger: Helion