Устойчивый код. Передовые практики и эвристика для инженеров-программистов.

Zrównoważony kod. Dobre praktyki i heurystyki dla inżynierów oprogramowania

Mark Seemann

Wielu zdolnych programistów uczestniczy w nieefektywnych, źle prowadzonych projektach. Inni muszą utrzymywać kod, który właściwie nigdy nie powinien ujrzeć światła dziennego. Źródeł tego rodzaju trudności jest wiele: programowanie samo w sobie jest niełatwym zagadnieniem, a tworzenie funkcjonalnych aplikacji najczęściej wymaga współdziałania wielu osób. Sprawia to, że kod budujący aplikację szybko zwiększa swoją złożoność, staje się niezrozumiały i bardzo trudny w utrzymaniu. Na szczęście te problemy zostały dostrzeżone i obecnie mamy wiele sposobów ich rozwiązywania.

Ta książka jest przeznaczona dla doświadczonych programistów, którzy chcą zdobyć lub pogłębić wiedzę o metodologiach i dobrych praktykach tworzenia złożonego oprogramowania. Stanowi interesująco napisany zbiór heurystyk i technik ułożonych w kolejności stosowania podczas rozwijania projektu programistycznego. Omówiono tu między innymi listy kontrolne, TDD, rozdzielenie poleceń i zapytań, Git, złożoność cyklomatyczną, przezroczystość referencyjną, wycinki pionowe, refaktoryzację zastanego kodu czy programowanie typu outside-in. Pokazano również, jak utrzymać właściwe tempo pracy podczas dodawania funkcjonalności, jak rozwiązywać problemy optymalizacji, enkapsulacji, a także projektowania API i testów jednostkowych. Poszczególne zagadnienia zostały zilustrowane kodem przykładowego projektu napisanego w C#, zrozumiałego dla każdego, kto zna dowolny język zorientowany obiektowo.

Dzięki książce zrozumiesz, jak:

• wybierać sprawdzone procesy
• tworzyć listy kontrolne ułatwiające polepszenie wyników
• unikać "paraliżu analitycznego"
• przeciwdziałać degradacji kodu i niepotrzebnej złożoności
• stosować lepsze techniki modyfikacji kodu i rozwiązywania problemów
• skuteczniej godzić wymogi wydajności i bezpieczeństwa

Celem nie jest pisanie kodu. Celem jest funkcjonalne oprogramowanie!

O autorze

Mark Seemann marzył o karierze gwiazdy rocka i próbował zostać ekonomistą, jego prawdziwym powołaniem jednak okazało się programowanie aplikacji internetowych i biznesowych. Jest certyfikowanym programistą Rockstara, autorem nagradzanych książek o programowaniu i prelegentem na prestiżowych konferencjach. Mieszka w Kopenhadze z żoną i dwójką dzieci.

Spis treści:

Przedmowa wydawcy serii

Wstęp

O autorze

CZĘŚĆ I. Przyspieszenie

Rozdział 1 Sztuka czy nauka?

• 1.1. Budowanie domu

  1.1.1. Problem związany z projektami

  1.1.2. Problem etapów

  1.1.3. Zależności

• 1.2. Pielęgnacja ogrodu

  1.2.1. Dzięki czemu ogród rośnie?

• 1.3. W kierunku inżynierii

  1.3.1. Oprogramowanie jako rzemiosło

  1.3.2. Heurystyki

  1.3.3. Wcześniejsze poglądy na inżynierię oprogramowania

  1.3.4. Ku inżynierii oprogramowania

• 1.4. Wniosek

Rozdział 2. Listy kontrolne

• 2.1. Pomaganie pamięci
• 2.2. Lista kontrolna dla nowego kodu źródłowego

  2.2.1. Użyj Gita

  2.2.2. Zautomatyzuj proces budowania

  2.2.3. Włącz wszystkie komunikaty o błędzie

• 2.3. Włączanie narzędzi kontrolnych dla istniejącego kodu

  2.3.1. Stopniowe ulepszenia

  2.3.2. Zhakuj swoją organizację

• 2.4. Wniosek

Rozdział 3. Radzenie sobie ze złożonością

• 3.1. Cel

  3.1.1. Zrównoważony rozwój

  3.1.2. Wartość

• 3.2. Dlaczego programowanie jest trudne

  3.2.1. Metafora mózgu

  3.2.2. Więcej kodu się czyta, niż pisze

  3.2.3. Czytelność

  3.2.4. Praca intelektualna

• 3.3. W stronę inżynierii oprogramowania

  3.3.1. Relacja z informatyką

  3.3.2. Ludzki kod

• 3.4. Wniosek

Rozdział 4. Pionowy wycinek

• 4.1. Zacznij od działającego oprogramowania

  4.1.1. Od otrzymania danych po ich utrwalenie

  4.1.2. Minimalny wycinek pionowy

• 4.2. Chodzący szkielet

  4.2.1. Test charakteryzacyjny

  4.2.2. Zasada Arrange-Act-Assert

  4.2.3. Moderowanie analizy statycznej

• 4.3. Podejście outside-in

  4.3.1. Przyjmowanie danych w formacie JSON

  4.3.2. Przesyłanie rezerwacji

  4.3.3. Test jednostkowy

  4.3.4. DTO i model domeny

  4.3.5. Fałszywy obiekt

  4.3.6. Interfejs repozytorium

  4.3.7. Tworzenie w repozytorium

  4.3.8. Konfiguracja zależności

• 4.4. Kończenie wycinka

  4.4.1. Schemat

  4.4.2. Repozytorium SQL

  4.4.3. Konfiguracja uwzględniająca bazę danych

  4.4.4. Wykonanie testu dymnego

  4.4.5. Test graniczny z fałszywą bazą danych

• 4.5. Wniosek

Rozdział 5. Enkapsulacja

• 5.1. Zapisywanie danych

  5.1.1. Zasada Transformation Priority Premise

  5.1.2. Test parametryzowany

  5.1.3. Kopiowanie obiektu DTO do modelu domeny

• 5.2. Walidacja

  5.2.1. Błędne daty

  5.2.2. Procedura czerwone, zielone, refaktoryzacja

  5.2.3. Liczby naturalne

  5.2.4. Prawo Postela

• 5.3. Ochrona niezmienników

  5.3.1. Zawsze poprawny

• 5.4. Wniosek

Rozdział 6. Triangulacja

• 6.1. Pamięć krótkoterminowa kontra długoterminowa

  6.1.1. Zastany kod i pamięć

• 6.2. Wydajność

  6.2.1. Zbyt wiele rezerwacji

  6.2.2. Adwokat diabła

  6.2.3. Istniejące rezerwacje

  6.2.4. Adwokat diabła kontra czerwone, zielone, refaktoryzacja

  6.2.5. Kiedy jest wystarczająco wiele testów?

• 6.3. Wniosek

Rozdział 7. Dekompozycja

• 7.1. Psucie się kodu

  7.1.1. Wartości progowe

  7.1.2. Złożoność cyklomatyczna

  7.1.3. Reguła 80/24

• 7.2. Kod, który mieści się w mózgu

  7.2.1. Kwiat sześciokątów

  7.2.2. Spójność

  7.2.3. Zazdrość o kod

  7.2.4. Między wierszami

  7.2.5. Parsuj, nie waliduj

  7.2.6. Architektura fraktalna

  7.2.7. Liczba zmiennych

• 7.3. Wniosek

Rozdział 8. Projektowanie API

• 8.1. Zasady projektowania API

  8.1.1. Afordancja

  8.1.2. Poka-Yoke

  8.1.3. Pisz dla czytelników

  8.1.4. Przedkładaj dobrze napisany kod nad komentarze

  8.1.5. Zastąpienie nazw znakami x

  8.1.6. Rozdzielenie poleceń i zapytań

  8.1.7. Hierarchia komunikacji

• 8.2. Przykładowy projekt API

  8.2.1. Maître D'

  8.2.2. Interakcja z opakowanym obiektem

  8.2.3. Szczegóły implementacyjne

• 8.3. Wniosek

Rozdział 9. Praca zespołowa

• 9.1. Git

  9.1.1. Komunikaty rewizji

  9.1.2. Ciągła integracja

  9.1.3. Małe rewizje

• 9.2. Zbiorowa własność kodu

  9.2.1. Programowanie w parach

  9.2.2. Mob Programming

  9.2.3. Opóźnienia w inspekcji kodu

  9.2.4. Odrzucenie zmian

  9.2.5. Recenzje kodu

  9.2.6. Żądania aktualizacji

• 9.3. Wniosek

CZĘŚĆ II. Zrównoważony rozwój

Rozdział 10. Rozbudowywanie kodu

• 10.1. Flagi funkcji

  10.1.1. Flaga kalendarza

• 10.2. Wzorzec dusiciela

  10.2.1. Dusiciel na poziomie metody

  10.2.2. Dusiciel na poziomie klasy

• 10.3. Wersjonowanie

  10.3.1. Wcześniejsze ostrzeżenie

• 10.4. Wniosek

Rozdział 11. Edycja testów jednostkowych

• 11.1. Refaktoryzacja testów jednostkowych

  11.1.1. Zmiana sieci bezpieczeństwa

  11.1.2. Dodawanie nowego kodu testowego

  11.1.3. Osobna refaktoryzacja testów i kodu produkcyjnego

• 11.2. Testy kończące się niepowodzeniem
• 11.3. Wniosek

Rozdział 12. Rozwiązywanie problemów

• 12.1. Zrozumienie

  12.1.1. Metoda naukowa

  12.1.2. Upraszczanie

  12.1.3. Gumowa kaczuszka

• 12.2. Defekty

  12.2.1. Odtwórz błędy za pomocą testów

  12.2.2. Wolne testy

  12.2.3. Defekty niedeterministyczne

• 12.3. Bisekcja

  12.3.1. Bisekcja za pomocą Gita

• 12.4. Wniosek

Rozdział 13. Separacja pojęć

• 13.1. Kompozycja

  13.1.1. Kompozycja zagnieżdżona

  13.1.2. Kompozycja sekwencyjna

  13.1.3. Przezroczystość referencyjna

• 13.2. Kwestie przekrojowe

  13.2.1. Zapisywanie zdarzeń w dziennikach

  13.2.2. Dekorator

  13.2.3. Co rejestrować w dziennikach

• 13.3. Wniosek

Rozdział 14. Rytm

• 14.1. Osobisty rytm

  14.1.1. Dzielenie czasu na bloki

  14.1.2. Rób przerwy

  14.1.3. Wykorzystuj czas celowo

  14.1.4. Pisanie bezwzrokowe

• 14.2. Rytm zespołowy

  14.2.1. Regularne aktualizowanie zależności

  14.2.2. Zaplanuj inne rzeczy

  14.2.3. Prawo Conwaya

• 14.3. Wniosek

Rozdział 15. Typowi podejrzani

• 15.1. Wydajność

  15.1.1. Spuścizna z przeszłości

  15.1.2. Czytelność

• 15.2. Bezpieczeństwo

  15.2.1. Metoda STRIDE

  15.2.2. Spoofing

  15.2.3. Tampering

  15.2.4. Repudiation

  15.2.5. Information Disclosure

  15.2.6. Denial of service

  15.2.7. Elevation of privilege

• 15.3. Inne techniki

  15.3.1. Testowanie oparte na właściwościach

  15.3.2. Behawioralna analiza kodu

• 15.4. Wniosek

Rozdział 16. Wycieczka

• 16.1. Nawigacja

  16.1.1. Ogólne spojrzenie

  16.1.2. Organizacja pliku

  16.1.3. Znajdowanie szczegółów

• 16.2. Architektura

  16.2.1. Monolit

  16.2.2. Cykle

• 16.3. Użycie

  16.3.1. Uczenie się na podstawie testów

  16.3.2. Słuchaj swoich testów

• 16.4. Wniosek

Dodatek A. Lista praktyk

• A.1. Adwokat diabła
• A.2. Arrange-act-assert
• A.3. Bisekcja
• A.4. Czerwone, zielone, refaktoryzacja
• A.5. Dekoratory dla aspektów przekrojowych
• A.6. Dusiciel
• A.7. Flaga funkcji
• A.8. Funkcyjny rdzeń, imperatywna powłoka
• A.9. Hierarchia komunikacji
• A.10. Inspekcja kodu
• A.11. Liczenie zmiennych
• A.12. Lista kontrolna dla nowego kodu źródłowego
• A.13. Model zagrożeń
• A.14. Odtwarzaj defekty w testach
• A.15. Parsuj, nie waliduj
• A.16. Prawo Postela
• A.17. Programowanie sterowane X
• A.18. Regularnie aktualizuj zależności
• A.19. Reguła 50/72
• A.20. Reguła 80/24
• A.21. Rozdzielenie poleceń i zapytań
• A.22. Rozdzielenie refaktoryzacji testów i refaktoryzacji kodu produkcyjnego
• A.23. Transformation Priority Premise
• A.24. Usprawiedliwiaj wyjątki od reguły
• A.25. Wersjonowanie semantyczne
• A.26. Wycinek
• A.27. Zastąp nazwy znakami X
• A.28. Złożoność cyklomatyczna

Bibliografia