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

• Tytuł: Zrównoważony kod. Dobre praktyki i heurystyki dla inżynierów oprogramowania
• Autor: Mark Seemann
• Tytuł oryginału: Code That Fits in Your Head: Heuristics for Software Engineering (Robert C. Martin Series)
• Tłumaczenie: Joanna Zatorska
• ISBN: 978-83-283-9227-4, 9788328392274
• Data wydania: 2022-09-27
• Format: Ebook
• Identyfikator pozycji: kodkto
• Wydawca: Helion