Zrównoważony kod. Dobre praktyki i heurystyki dla inżynierów oprogramowania - ebook
Zrównoważony kod. Dobre praktyki i heurystyki dla inżynierów oprogramowania - ebook
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!
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
Kategoria: | Programowanie |
Zabezpieczenie: |
Watermark
|
ISBN: | 978-83-283-9227-4 |
Rozmiar pliku: | 6,7 MB |