O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Kod doskonały. Jak tworzyć oprogramowanie pozbawione błędów. Wydanie II

Book Description

Książka jest przejrzystą kompilacją najlepszych technik programowania, zdobyła wielkie uznanie w środowisku zawodowców i studentów, osiągając miano podręcznika kultowego.

Table of Contents

  1. Kod Doskonały: Jak tworzyć oprogramowanie pozbawione błędów
  2. Dedication
  3. Napisali o tej książce
  4. Wstęp
    1. Dla kogo jest ta książka?
      1. Doświadczeni programiści
      2. Kierownicy zespołów
      3. Programiści bez formalnego wykształcenia
      4. Studenci
    2. Gdzie można znaleźć podobne informacje?
    3. Główne zalety tego podręcznika
    4. Dlaczego napisałem tę książkę
      1. Temat programowania jest zaniedbywany
      2. Programowanie jest ważne
      3. Nie ma podobnych książek
    5. Od autora
  5. Podziękowania
  6. Listy kontrolne
  7. Tabele
  8. Rysunki
  9. I. Proces budowy oprogramowania
    1. 1. Budowa oprogramowania
      1. 1.1. Czym jest budowa oprogramowania
      2. 1.2. Znaczenie procesu budowy oprogramowania
      3. 1.3. Jak korzystać z tej książki
      4. Podsumowanie
    2. 2. Metafory procesu programowania
      1. 2.1. Znaczenie metafor
      2. 2.2. Jak korzystać z metafor w programowaniu
      3. 2.3. Popularne metafory programowania
        1. Pisanie listów — pisanie kodu
        2. Praca na roli — hodowanie systemu
        3. Hodowla ostryg — przyrastanie systemu
        4. Programista jako budowniczy — budowa oprogramowania
        5. Przybornik programisty — narzędzia i moduły
        6. Łączenie metafor
      4. Więcej informacji
      5. Podsumowanie
    3. 3. Przed programowaniem — przygotowania
      1. 3.1. Przygotowania i ich znaczenie
        1. Czy współcześnie przygotowania wciąż obowiązują?
        2. Przyczyny braków w przygotowaniu projektu
        3. Przekonujące uzasadnienie konieczności wykonania przed programowaniem czynności wstępnych
          1. Oprzyj się na logice
          2. Oprzyj się na analogiach
          3. Oprzyj się na danych
          4. Test gotowości przełożonego
      2. 3.2. Określanie rodzaju budowanego oprogramowania
        1. Wpływ podejścia iteracyjnego na przygotowania
        2. Wybór między podejściem iteracyjnym a sekwencyjnym
      3. 3.3. Definicja problemu
      4. 3.4. Określenie wymagań
        1. Czemu służy oficjalna specyfikacja wymagań?
        2. Mit stabilnych wymagań
        3. Zmiany wymagań w trakcie budowy oprogramowania
      5. 3.5. Architektura
        1. Typowe składniki architektury
          1. Organizacja programu
          2. Podstawowe klasy programu
          3. Organizacja danych
          4. Reguły biznesowe
          5. Projekt interfejsu użytkownika
          6. Zarządzanie zasobami
          7. Zabezpieczenia
          8. Wydajność
          9. Skalowalność
          10. Współdziałanie
          11. Internacjonalizacja i lokalizacja
          12. Wejście-wyjście
          13. Przetwarzanie błędów
          14. Zabezpieczenia przed awariami
        2. Wykonalność
        3. Nadmiar konstrukcyjny
          1. Kupować czy budować
          2. Decyzje o wykorzystaniu istniejącej bazy
          3. Strategia zmian
          4. Ogólny poziom jakości architektury
      6. 3.6. Ilość czasu poświęcanego na przygotowania
      7. Więcej informacji
        1. Wymagania
        2. Architektura oprogramowania
        3. Metodyki wytwarzania oprogramowania
      8. Podsumowanie
    4. 4. Kluczowe decyzje konstrukcyjne
      1. 4.1. Wybór języka programowania
        1. Opisy poszczególnych języków
          1. Ada
          2. Język asemblera
          3. C
          4. C++
          5. C#
          6. Cobol
          7. Fortran
          8. Java
          9. JavaScript
          10. Perl
          11. PHP
          12. Python
          13. SQL
          14. Visual Basic
      2. 4.2. Konwencje programowania
      3. 4.3. Twoje położenie na fali technologii
        1. Przykład programowania do języka
      4. 4.4. Wybór podstawowych praktyk programowania
      5. Podsumowanie
  10. II. Pisanie dobrego kodu
    1. 5. Projektowanie
      1. 5.1. Podstawowe problemy projektowania
        1. Projektowanie to problem złośliwy
        2. Projektowanie to proces niedoskonały
        3. Projektowanie opiera się na kompromisach i priorytetach
        4. Projektowanie wiąże się z ograniczeniami
        5. Projektowanie ma charakter niedeterministyczny
        6. Projektowanie jest procesem heurystycznym
        7. Projekt rozwija się
      2. 5.2. Podstawowe pojęcia projektowania
        1. Zarządzanie złożonością — Główny Imperatyw Techniczny Oprogramowania
          1. Trudności akcydentalne i trudności istotne
          2. Znaczenie zarządzania złożonością
          3. Jak walczyć ze złożonością
        2. Pożądane cechy projektu
        3. Poziomy projektowania
          1. Poziom 1.: system
          2. Poziom 2.: podział na podsystemy lub pakiety
            1. Typowe podsystemy
          3. Poziom 3.: podział na klasy
            1. Klasy a obiekty
          4. Poziom 4.: podział na procedury
          5. Poziom 5.: wewnętrzne projektowanie procedur
      3. 5.3. Heurystyki — narzędzia projektanta
        1. Znajdź obiekty świata rzeczywistego
        2. Buduj spójne abstrakcje
        3. Hermetyzuj szczegóły implementacji
        4. Stosuj dziedziczenie — gdy upraszcza to projekt
        5. Ukrywaj tajemnice (ukrywanie informacji)
          1. Tajemnice i prawo do prywatności
          2. Przykład ukrywania informacji
          3. Dwa rodzaje tajemnic
          4. Przeszkody w ukrywaniu informacji
          5. Znaczenie ukrywania informacji
        6. Identyfikuj obszary potencjalnych zmian
          1. Przewidywanie stopnia potencjalnych zmian
        7. Zachowaj luźne powiązania
          1. Miary zależności
          2. Rodzaje powiązań
        8. Szukaj typowych wzorców projektowych
        9. Inne heurystyki
          1. Staraj się o dużą kohezję
          2. Buduj hierarchie
          3. Formalizuj kontrakty klas
          4. Przypisuj zakresy odpowiedzialności
          5. Projektuj pod kątem testów
          6. Unikaj niepowodzeń
          7. Uważnie wybieraj czas wiązania
          8. Centralizuj punkty kontroli
          9. Rozważaj użycie najbardziej prymitywnych środków
          10. Narysuj diagram
          11. Zachowaj modularność projektu
        10. Heurystyki projektowania — podsumowanie
        11. Stosowanie heurystyk
      4. 5.4. Techniki projektowania
        1. Iteruj
        2. Dziel i rządź
        3. Podejścia zstępujące i wstępujące
          1. Zalety metody zstępującej
          2. Zalety metody wstępującej
          3. Nie ma metody lepszej
        4. Prototypowanie eksperymentalne
        5. Projektowanie zespołowe
        6. Kiedy zakończyć pracę nad projektem?
        7. Dokumentowanie pracy
      5. 5.5. Uwagi o popularnych metodykach pracy
      6. Więcej informacji
        1. Projektowanie oprogramowania — ogólnie
        2. Teoria projektowania oprogramowania
        3. Wzorce projektowe
        4. Projektowanie — ogólnie
        5. Normy
      7. Podsumowanie
    2. 6. Klasy z klasą
      1. 6.1. Abstrakcyjne typy danych
        1. Przykład zastosowania ADT
        2. Korzyści ze stosowania ADT
        3. Kolejne przykłady ADT
        4. Wiele instancji danych w środowisku nieobiektowym
        5. ADT a klasy
      2. 6.2. Dobry interfejs klasy
        1. Dobra abstrakcja
        2. Dobra hermetyzacja
      3. 6.3. Problemy projektowania i implementacji
        1. Zawieranie (relacja „ma”)
        2. Dziedziczenie (relacja „jest”)
          1. Wielodziedziczenie (dziedziczenie wielokrotne)
          2. Skąd tyle reguł stosowania dziedziczenia?
        3. Funkcje i dane składowe
        4. Konstruktory
      4. 6.4. Przesłanki dla utworzenia klasy
        1. Klasy, których należy unikać
        2. Przesłanki dla utworzenia klasy — podsumowanie
      5. 6.5. Specyfika języka
      6. 6.6. Pakiety klas
      7. Więcej informacji
        1. Klasy — ogólnie
        2. C++
        3. Java
        4. Visual Basic
      8. Podsumowanie
    3. 7. Procedury wysokiej jakości
      1. 7.1. Przesłanki utworzenia procedury
        1. Operacje z pozoru zbyt proste, aby tworzyć procedury
        2. Przesłanki utworzenia procedury — podsumowanie
      2. 7.2. Projektowanie na poziomie procedur
      3. 7.3. Dobra nazwa procedury
      4. 7.4. Jak długa może być procedura?
      5. 7.5. Jak używać parametrów procedur
      6. 7.6. Używanie funkcji
        1. Kiedy użyć funkcji, a kiedy procedury
        2. Wartość zwracana przez funkcję
      7. 7.7. Makra i procedury inline
        1. Ograniczenia w stosowaniu makr
        2. Procedury inline
      8. Podsumowanie
    4. 8. Programowanie defensywne
      1. 8.1. Zabezpieczanie programu przed niewłaściwymi danymi wejściowymi
      2. 8.2. Asercje
        1. Budowanie własnego mechanizmu asercji
        2. Stosowanie asercji
      3. 8.3. Mechanizmy obsługi błędów
        1. Poprawność a odporność
        2. Obsługa błędów a projekt wysokiego poziomu
      4. 8.4. Wyjątki
      5. 8.5. Ograniczanie zasięgu szkód powodowanych przez błędy
        1. Ograniczanie zasięgu szkód a asercje
      6. 8.6. Kod wspomagający debugowanie
        1. Nie przenoś każdego ograniczenia wersji finalnej na wersję roboczą
        2. Wcześnie wprowadzaj kod wspomagający debugowanie
        3. Stosuj programowanie ofensywne
        4. Przygotuj się na usuwanie kodu wspomagającego
      7. 8.7. Ilość kodu defensywnego w wersji finalnej
      8. 8.8. Defensywne podejście do programowania defensywnego
      9. Więcej informacji
        1. Zabezpieczenia
        2. Asercje
        3. Wyjątki
      10. Podsumowanie
    5. 9. Proces Programowania w Pseudokodzie
      1. 9.1. Budowanie klas i procedur krok po kroku
        1. Budowanie klasy
        2. Budowanie procedury
      2. 9.2. Pseudokod dla zaawansowanych
      3. 9.3. Budowanie procedur metodą PPP
        1. Projektowanie procedury
        2. Pisanie kodu procedury
        3. Sprawdzanie kodu procedury
        4. Usuwanie pozostałości
        5. Powtórzenia
      4. 9.4. Alternatywy dla pseudokodu
      5. Podsumowanie
  11. III. Zmienne
    1. 10. Zmienne w programie
      1. 10.1. Podstawowa wiedza o danych
        1. Test wiedzy o danych
        2. Więcej informacji o typach danych
      2. 10.2. Deklarowanie zmiennych
        1. Deklaracje niejawne
      3. 10.3. Inicjalizowanie zmiennych
      4. 10.4. Zakres
        1. Lokalizuj odwołania do zmiennych
        2. Skracaj czas aktywności zmiennych
        3. Mierzenie czasu aktywności zmiennej
        4. Metody ograniczania zakresu
        5. Minimalizowanie zakresu — uwagi
      5. 10.5. Trwałość
      6. 10.6. Czas wiązania
      7. 10.7. Związek między typami danych i strukturami sterowania
      8. 10.8. Jedno przeznaczenie każdej zmiennej
      9. Podsumowanie
    2. 11. Potęga nazwy zmiennej
      1. 11.1. Wybieranie dobrej nazwy
        1. Najważniejsza zasada wyboru nazw
        2. Ukierunkowanie na problem
        3. Optymalna długość nazwy
        4. Wpływ zakresu na nazwy zmiennych
        5. Kwalifikatory wyników obliczeń
        6. Typowe przeciwieństwa w nazwach zmiennych
      2. 11.2. Nazwy a rodzaje danych
        1. Indeksy pętli
        2. Zmienne stanu
        3. Zmienne tymczasowe
        4. Zmienne logiczne
        5. Typy wyliczeniowe
        6. Stałe nazwane
      3. 11.3. Potęga konwencji nazw
        1. Czemu służą konwencje?
        2. Kiedy wprowadzać konwencje nazw
        3. Stopnie formalizmu
      4. 11.4. Nieformalne konwencje nazw
        1. Konwencje niezależne od języka
        2. Konwencje specyficzne dla języka
          1. Język C
          2. Język C++
          3. Język Java
          4. Język Visual Basic
        3. Programowanie w wielu językach
        4. Przykładowy zbiór konwencji nazw
      5. 11.5. Standardowe prefiksy
        1. Skróty typów użytkownika (UDT)
        2. Prefiksy semantyczne
        3. Zalety stosowania standardowych prefiksów
      6. 11.6. Nazwy krótkie a czytelne
        1. Ogólne zasady tworzenia skrótów
        2. Skróty fonetyczne
        3. Wskazówki praktyczne
      7. 11.7. Nazwy, których należy unikać
      8. Podsumowanie
    3. 12. Podstawowe typy danych
      1. 12.1. Liczby
      2. 12.2. Liczby całkowite
      3. 12.3. Liczby zmiennoprzecinkowe
      4. 12.4. Znaki i ciągi znakowe
        1. Ciągi znakowe w języku C
      5. 12.5. Zmienne logiczne
      6. 12.6. Typy wyliczeniowe
        1. Jeżeli język nie ma typów wyliczeniowych
      7. 12.7. Stałe nazwane
      8. 12.8. Tablice
      9. 12.9. Tworzenie własnych typów (aliasy)
        1. Jak wyglądają definicje własnych typów w Pascalu i Adzie?
        2. Tworzenie typów — wskazówki
      10. Podsumowanie
    4. 13. Inne typy danych
      1. 13.1. Struktury
      2. 13.2. Wskaźniki
        1. Paradygmat wskaźników
          1. Lokalizacja w pamięci
          2. Wiedza o sposobie interpretacji zawartości
        2. Praca ze wskaźnikami
        3. Wskaźniki w języku C++
        4. Wskaźniki w języku C
      3. 13.3. Dane globalne
        1. Typowe problemy z danymi globalnymi
        2. Przesłanki użycia danych globalnych
        3. Dane globalne są ostatecznością
        4. Procedury dostępowe zamiast danych globalnych
          1. Zalety procedur dostępowych
          2. Stosowanie procedur dostępowych
        5. Jak redukować liczbę problemów z danymi globalnymi
      4. Więcej informacji
      5. Podsumowanie
  12. IV. Instrukcje
    1. 14. Struktura kodu liniowego
      1. 14.1. Instrukcje, które wymagają określonej kolejności
      2. 14.2. Instrukcje, których kolejność nie ma znaczenia
        1. Kolejność czytania kodu
        2. Grupowanie powiązanych instrukcji
      3. Podsumowanie
    2. 15. Instrukcje warunkowe
      1. 15.1. Instrukcje if
        1. Proste instrukcje if-then
        2. Łańcuchy instrukcji if-then-else
      2. 15.2. Instrukcje case
        1. Wybór optymalnej kolejności przypadków
        2. Budowanie instrukcji case
      3. Podsumowanie
    3. 16. Pętle
      1. 16.1. Wybieranie rodzaju pętli
        1. Kiedy używać pętli while
          1. Pętla z testem na początku
          2. Pętla z testem na końcu
        2. Kiedy używać pętli przerywanej
          1. Zwykłe pętle przerywane
          2. Nietypowe pętle przerywane
        3. Kiedy używać pętli for
        4. Kiedy używać pętli foreach
      2. 16.2. Sterowanie pętlą
        1. Wejście do pętli
        2. Kod wewnątrz pętli
        3. Wyjście z pętli
          1. Wczesne wyjście z pętli
        4. Sprawdzanie wartości brzegowych
        5. Zmienne pętli
        6. Jak długa powinna być pętla?
      3. 16.3. Łatwe tworzenie pętli — od wewnątrz
      4. 16.4. Pętle i tablice
      5. Podsumowanie
    4. 17. Nietypowe struktury sterowania
      1. 17.1. Wiele wyjść z procedury
      2. 17.2. Rekurencja
        1. Przykłady rekurencji
        2. Stosowanie rekurencji
      3. 17.3. Instrukcja goto
        1. Argumenty przeciwko instrukcji goto
        2. Argumenty za stosowaniem instrukcji goto
        3. Argumenty, które nic nie wnoszą
        4. Instrukcja goto i przetwarzanie błędów
          1. Porównanie metod
        5. Instrukcja goto i wspólna klauzula else
        6. Instrukcja goto — podsumowanie
      4. 17.4. Nietypowe struktury sterowania z perspektywy
      5. Więcej informacji
        1. Instrukcje return
        2. Instrukcje goto
      6. Podsumowanie
    5. 18. Metody oparte na tabelach
      1. 18.1. Metody oparte na tabelach — wprowadzenie
        1. Dwie decyzje wymagane przy wprowadzaniu tabel
      2. 18.2. Tabele o dostępie bezpośrednim
        1. Przykład dni miesiąca
        2. Przykład stawek ubezpieczenia
        3. Przykład elastycznego formatu komunikatu
          1. Metoda konwencjonalna
          2. Metoda obiektowa
          3. Metoda oparta na tabeli
        4. Preparowanie kluczy wyszukiwania
      3. 18.3. Tabele o dostępie indeksowym
      4. 18.4. Tabele o dostępie schodkowym
      5. 18.5. Inne metody wyszukiwania w tabelach
      6. Podsumowanie
    6. 19. Ogólne problemy sterowania
      1. 19.1. Wyrażenia logiczne
        1. Używanie true i false
        2. Upraszczanie złożonych wyrażeń
        3. Pozytywne formułowanie wyrażeń
        4. Nawiasy a jednoznaczność wyrażeń
        5. Znaczenie sposobu przeliczania wyrażeń logicznych
        6. Zachowywanie kierunku osi liczbowej
        7. Porównania z zerem
        8. Typowe problemy z wyrażeniami logicznymi
      2. 19.2. Instrukcje złożone (bloki)
      3. 19.3. Instrukcje puste
      4. 19.4. Praca z głębokimi zagnieżdżeniami
        1. Podsumowanie metod redukowania zagnieżdżeń
      5. 19.5. Programowanie strukturalne
        1. Trzy komponenty programowania strukturalnego
          1. Sekwencja
          2. Wybór
          3. Iterowanie
      6. 19.6. Struktury sterujące i złożoność
        1. Jak ważna jest złożoność?
        2. Redukowanie złożoności
          1. Jak mierzyć złożoność
          2. Jak wykorzystać pomiar złożoności
        3. Inne rodzaje złożoności
      7. Podsumowanie
  13. V. Sprawna praca z kodem
    1. 20. Jakość oprogramowania
      1. 20.1. Składowe jakości
      2. 20.2. Metody podwyższania jakości
        1. Proces budowy oprogramowania
        2. Określanie celów
      3. 20.3. Skuteczność metod podwyższania jakości
        1. Procent wykrytych defektów
        2. Koszt wyszukiwania defektów
        3. Koszt usuwania defektów
      4. 20.4. Kiedy przeprowadzać kontrolę jakości
      5. 20.5. Ogólna Zasada Jakości Oprogramowania
      6. Więcej informacji
      7. Normy
      8. Podsumowanie
    2. 21. Programowanie zespołowe
      1. 21.1. Przegląd metod programowania zespołowego
        1. Programowanie zespołowe uzupełnia inne metody zapewniania jakości
        2. Programowanie zespołowe sprzyja dzieleniu się wiedzą i podtrzymuje specyficzną kulturę organizacji
        3. Wspólnota własności obejmuje wszystkie formy pracy zespołowej
        4. Praca zespołowa daje dobre efekty nie tylko przy pisaniu kodu
      2. 21.2. Programowanie w parach
        1. Ważne zasady programowania w parach
        2. Zalety programowania w parach
      3. 21.3. Formalne inspekcje
        1. Czego spodziewać się po inspekcjach?
        2. Role w inspekcji
        3. Procedura inspekcji
          1. Optymalizowanie inspekcji
        4. Inspekcje i ego
        5. Inspekcje i Kod doskonały
        6. Podsumowanie
      4. 21.4. Inne metody programowania zespołowego
        1. Oględziny
          1. Czego spodziewać się po oględzinach?
        2. Czytanie kodu
        3. Pokazy fajerwerków
      5. Porównanie metod pracy zespołowej
      6. Więcej informacji
        1. Programowanie w parach
        2. Inspekcje
        3. Normy
      7. Podsumowanie
    3. 22. Testowanie
      1. 22.1. Rola testów programisty
        1. Testowanie w procesie programowania
      2. 22.2. Zalecane podejście do testów programisty
        1. „Test first” czy „test last”?
        2. Typowe problemy z samodzielnym testowaniem
      3. 22.3. Praktyczne techniki testowania
        1. Niepełne testowanie
        2. Pełne testowanie bazowe
        3. Testowanie przepływu danych
          1. Kombinacje stanów
        4. Dzielenie według równoważności
        5. Przewidywanie błędów
        6. Analiza wartości granicznych
          1. Złożone wartości graniczne
        7. Klasy złych danych
        8. Klasy dobrych danych
        9. Ułatwianie ręcznego sprawdzania wyników
      4. 22.4. Typowe błędy
        1. Które klasy zawierają najwięcej błędów?
        2. Kategorie błędów
        3. Udział błędów programisty
        4. Ilu błędów oczekiwać?
        5. Błędy w procesie testowania
      5. 22.5. Narzędzia wspomagające testowanie
        1. Budowanie rusztowania do testów pojedynczych klas
        2. Narzędzia do porównywania danych
        3. Generatory danych testowych
        4. Monitory pokrycia
        5. Rejestrowanie danych
        6. Debuggery symboliczne
        7. Narzędzia zakłócające pracę systemu
        8. Bazy błędów
      6. 22.6. Usprawnianie testów
        1. Planowanie testów
        2. Powtarzanie testów (testowanie regresyjne)
        3. Automatyzacja testów
      7. 22.7. Gromadzenie informacji o testach
        1. Prywatne zbiory informacji o testach
      8. Więcej informacji
        1. Testowanie
        2. Rusztowanie testów
        3. Metodyka „test first”
        4. Normy
      9. Podsumowanie
    4. 23. Debugowanie
      1. 23.1. Wprowadzenie
        1. Debugowanie a jakość oprogramowania
        2. Różnice w efektywności debugowania
        3. Wykorzystanie defektów dla własnej korzyści
        4. Nieefektywne debugowanie
          1. Jak źle debugować
          2. Debugowanie oparte na przesądach
      2. 23.2. Wyszukiwanie defektu
        1. Naukowa metoda debugowania
          1. Ustabilizuj błąd
          2. Zlokalizuj źródło błędu
        2. Wyszukiwanie defektów — porady
          1. Debugowanie „brute force”
        3. Błędy składniowe
      3. 23.3. Usuwanie defektu
      4. 23.4. Debugowanie a psychologia
        1. Wpływ nastawienia psychicznego na dostrzeganie błędów
        2. Dystans psychologiczny
      5. 23.5. Narzędzia debugowania — oczywiste i mniej oczywiste
        1. Narzędzia porównujące kod
        2. Ostrzeżenia kompilatora
        3. Dokładniejsze sprawdzanie składni i logiki
        4. Programy profilujące
        5. Platformy testowania i rusztowania
        6. Debuggery
      6. Więcej informacji
      7. Podsumowanie
    5. 24. Refaktoryzacja
      1. 24.1. Ewolucja oprogramowania i jej odmiany
        1. Filozofia ewolucji oprogramowania
      2. 24.2. Refaktoryzacje — wprowadzenie
        1. Przesłanki refaktoryzacji
        2. Kiedy nie refaktoryzować
      3. 24.3. Wybrane refaktoryzacje
        1. Refaktoryzacje na poziomie danych
        2. Refaktoryzacje na poziomie instrukcji
        3. Refaktoryzacje na poziomie procedury
        4. Refaktoryzacje implementacji klasy
        5. Refaktoryzacje interfejsu klasy
        6. Refaktoryzacje na poziomie systemu
      4. 24.4. Bezpieczne przekształcanie kodu
        1. Zły czas na refaktoryzację
      5. 24.5. Strategie refaktoryzacji
      6. Więcej informacji
      7. Podsumowanie
    6. 25. Strategie optymalizacji kodu
      1. 25.1. Wydajność kodu
        1. Charakterystyka jakościowa a wydajność
        2. Wydajność a optymalizacja kodu
        3. Specyfikacja wymagań
        4. Projekt programu
        5. Projekty klas i procedur
        6. Interakcje z systemem operacyjnym
        7. Kompilacja kodu
        8. Platforma sprzętowa
        9. Optymalizacja kodu
      2. 25.2. Optymalizowanie kodu
        1. Zasada Pareto
        2. Opowieści różnej treści
        3. Kiedy optymalizować
        4. Optymalizacje kompilatora
      3. 25.3. Rodzaje otyłości i lenistwa
        1. Typowe przyczyny niskiej efektywności
        2. Przeciętny koszt typowych operacji
      4. 25.4. Pomiary
        1. Pomiary muszą być dokładne
      5. 25.5. Iterowanie
      6. 25.6. Strategie optymalizacji kodu — podsumowanie
      7. Więcej informacji
        1. Wydajność
        2. Algorytmy i typy danych
      8. Podsumowanie
    7. 26. Metody optymalizacji kodu
      1. 26.1. Struktury logiczne
        1. Przerywanie testów po uzyskaniu wyniku
        2. Porządkowanie testów według częstości
        3. Porównywanie wydajności podobnych struktur logiki programu
        4. Zastępowanie złożonych wyrażeń wyszukiwaniem w tabeli
        5. Opóźnianie obliczeń
      2. 26.2. Pętle
        1. Przenoszenie decyzji
        2. Scalanie pętli
        3. „Prostowanie” pętli
        4. Zmniejszanie ilości pracy w pętli
        5. Wartości ograniczające
        6. Umieszczanie najczęściej wykonywanej pętli wewnątrz
        7. Zmniejszanie obciążenia
      3. 26.3. Przekształcenia danych
        1. Zastępowanie liczb zmiennoprzecinkowych całkowitymi
        2. Stosowanie jak najmniejszej liczby wymiarów tablic
        3. Zmniejszanie liczby operacji dostępu do tabel
        4. Użycie indeksów pomocniczych
          1. Indeks długości ciągu
          2. Niezależna, równoległa struktura indeksowa
        5. Buforowanie
      4. 26.4. Wyrażenia
        1. Wykorzystywanie tożsamości algebraicznych
        2. Zmniejszanie obciążenia
        3. Inicjalizowanie w czasie kompilacji
        4. Oszczędne stosowanie procedur systemowych
        5. Używanie właściwych typów stałych
        6. Wstępne obliczanie wartości
        7. Eliminowanie wspólnych części wyrażeń
      5. 26.5. Procedury
        1. Przenoszenie kodu do procedury wywołującej
      6. 26.6. Reimplementacja w języku niskiego poziomu
      7. 26.7. Im bardziej świat się zmienia, tym więcej zostaje bez zmian
      8. Więcej informacji
      9. Podsumowanie
  14. VI. Środowisko programowania
    1. 27. Jak rozmiar programu wpływa na jego budowę
      1. 27.1. Wielkość projektu a komunikacja
      2. 27.2. Skala rozmiarów projektów
      3. 27.3. Wpływ wielkości projektu na liczbę błędów
      4. 27.4. Wpływ wielkości projektu na efektywność pracy
      5. 27.5. Wpływ wielkości projektu na wykonywaną pracę
        1. Wielkość a udział poszczególnych czynności
        2. Programy, produkty, systemy i produkty systemowe
        3. Wielkość projektów a stosowana metodyka pracy
      6. Więcej informacji
      7. Podsumowanie
    2. 28. Zarządzanie w programowaniu
      1. 28.1. Zachęcanie do budowy dobrego kodu
        1. Metody wprowadzania standardów
        2. Metody zachęcania do budowy dobrego kodu
        3. Rola tej książki
      2. 28.2. Zarządzanie konfiguracją
        1. Czym jest zarządzanie konfiguracją?
        2. Zmiany w wymaganiach i projekcie
        3. Zmiany w kodzie programu
        4. Wersje narzędzi
        5. Konfiguracje komputerów
        6. System kopii zapasowych
        7. Więcej informacji — zarządzanie konfiguracją
      3. 28.3. Budowanie harmonogramu
        1. Metody szacowania ilości pracy
        2. Szacowanie ilości pracy przy programowaniu
        3. Wpływ różnych czynników na harmonogram pracy
        4. Szacowanie czy kontrola?
        5. Co robić, gdy projekt się spóźnia
        6. Więcej informacji — szacowanie wielkości projektu
      4. 28.4. Pomiary
        1. Więcej informacji — miary oprogramowania
      5. 28.5. Ludzkie traktowanie programistów
        1. Jak programiści spędzają czas?
        2. Różnice wydajności i jakości pracy
          1. Różnice między programistami
          2. Różnice między zespołami
        3. Wojny religijne
        4. Miejsce pracy
        5. Więcej informacji — programiści jako ludzie
      6. 28.6. Współpraca z przełożonymi
        1. Więcej informacji — zarządzanie w programowaniu
        2. Normy
      7. Podsumowanie
    3. 29. Integracja
      1. 29.1. Znaczenie metod integracji
      2. 29.2. Częstość integracji — końcowa czy przyrostowa?
        1. Integracja końcowa
        2. Integracja przyrostowa
        3. Zalety integracji przyrostowej
      3. 29.3. Przyrostowe strategie integracji
        1. Integracja zstępująca
        2. Integracja wstępująca
        3. Integracja warstwowa
        4. Integracja według ryzyka
        5. Integracja funkcjonalna
        6. Integracja typu T
        7. Integracja — podsumowanie
      4. 29.4. Codzienna kompilacja i test dymowy
        1. W jakich projektach można stosować codzienną kompilację?
        2. Integracja ciągła
        3. Więcej informacji
          1. Integracja
          2. Praca przyrostowa
      5. Podsumowanie
    4. 30. Narzędzia programowania
      1. 30.1. Narzędzia do projektowania
      2. 30.2. Narzędzia do pracy z kodem źródłowym
        1. Edycja
          1. Zintegrowane środowiska programowania (IDE)
          2. Wyszukiwanie i zastępowanie w wielu plikach
          3. Narzędzia typu Diff
          4. Narzędzia do scalania
          5. Narzędzia formatujące kod źródłowy
          6. Generatory opisu interfejsu
          7. Szablony
          8. Generatory odnośników
          9. Generatory hierarchii klas
        2. Analiza jakości kodu
          1. Kontrolery składniowe i semantyczne
          2. Narzędzia pomiarowe
        3. Przekształcanie kodu źródłowego
          1. Narzędzia do refaktoryzacji
          2. Narzędzia przekształcające strukturę kodu
          3. Translatory kodu
        4. Kontrola wersji
        5. Słowniki danych
      3. 30.3. Narzędzia do pracy z kodem wykonywalnym
        1. Generowanie kodu
          1. Kompilatory i linkery
          2. Narzędzia kompilacji
          3. Biblioteki kodu
          4. Generatory kodu
          5. Instalowanie
          6. Preprocesory
        2. Debugowanie
        3. Testowanie
        4. Optymalizacja kodu
          1. Narzędzia profilujące
          2. Listingi asemblera i deasemblery
      4. 30.4. Środowiska narzędzi programowania
      5. 30.5. Budowanie własnych narzędzi
        1. Narzędzia specyficzne dla projektu
        2. Skrypty
      6. 30.6. Narzędzia przyszłości
      7. Więcej informacji
      8. Podsumowanie
  15. VII. Rzemiosło programisty
    1. 31. Układ i styl
      1. 31.1. Wprowadzenie
        1. Ekstrema formatowania
        2. Podstawowa Zasada Formatowania
        3. Interpretacja programu przez komputer i przez człowieka
        4. Jaka jest wartość dobrego układu?
        5. Formatowanie jako religia
        6. Cele formatowania
          1. Jak wykorzystać cele formatowania
      2. 31.2. Techniki formatowania
        1. Białe znaki
        2. Nawiasy
      3. 31.3. Style formatowania
        1. Czyste bloki
        2. Emulowane czyste bloki
        3. Wyróżnianie granic bloków parami begin-end (nawiasami klamrowymi)
        4. Wyrównywanie z głębokimi wcięciami
        5. Który schemat formatowania jest najlepszy?
      4. 31.4. Formatowanie struktur sterujących
        1. Szczegóły formatowania bloków struktur sterujących
        2. Inne aspekty formatowania
      5. 31.5. Formatowanie instrukcji
        1. Długość instrukcji
        2. Zwiększanie przejrzystości dodatkowymi spacjami
        3. Formatowanie kontynuacji wierszy
        4. Nie więcej niż jedna instrukcja w wierszu
        5. Formatowanie deklaracji danych
      6. 31.6. Formatowanie komentarzy
      7. 31.7. Formatowanie procedur
      8. 31.8. Formatowanie klas
        1. Układ interfejsu klasy
        2. Układ implementacji klasy
        3. Układ kodu w plikach i w programie
      9. Więcej informacji
      10. Podsumowanie
    2. 32. Kod, który opisuje się sam
      1. 32.1. Zewnętrzna dokumentacja programu
      2. 32.2. Styl programowania jako dokumentacja
      3. 32.3. Komentować czy nie komentować
        1. Komento, czyli pamiętaj o komentarzach
      4. 32.4. Zasady pisania dobrych komentarzy
        1. Rodzaje komentarzy
          1. Powtórzenia kodu
          2. Objaśnienia do kodu
          3. Znaczniki w kodzie
          4. Komentarze podsumowujące
          5. Komentarze, które informują o przeznaczeniu kodu
          6. Informacje niemożliwe do wyrażenia w kodzie
        2. Efektywne komentowanie kodu
        3. Optymalna liczba komentarzy
      5. 32.5. Metody pisania komentarzy
        1. Komentarze do pojedynczych wierszy
          1. Komentarze na końcu wierszy i związane z nimi problemy
          2. Kiedy używać komentarzy na końcu wierszy
        2. Komentarze do akapitów kodu
        3. Komentarze do deklaracji danych
        4. Komentarze do struktur sterujących
        5. Komentarze do procedur
        6. Komentarze do klas, plików i programów
          1. Opisy klas
        7. Komentarze do plików
          1. Paradygmat książki w opisie programu
      6. 32.6. Normy IEEE
        1. Normy programowania
        2. Normy zapewniania jakości
        3. Normy zarządzania
        4. Zbiory i przeglądy norm
      7. Więcej informacji
      8. Podsumowanie
    3. 33. Cechy charakteru
      1. 33.1. Czy osobowość jest bez znaczenia?
      2. 33.2. Inteligencja i skromność
      3. 33.3. Ciekawość
      4. 33.4. Uczciwość intelektualna
      5. 33.5. Komunikacja i współpraca
      6. 33.6. Kreatywność i dyscyplina
      7. 33.7. Lenistwo
      8. 33.8. Cechy, które znaczą mniej, niż myślisz
        1. Wytrwałość
        2. Doświadczenie
        3. Gorączka programowania
      9. 33.9. Nawyki
      10. Więcej informacji
      11. Podsumowanie
    4. 34. Powracające wątki — przegląd
      1. 34.1. Walka ze złożonością
      2. 34.2. Wybierz swój proces
      3. 34.3. Pisz programy dla ludzi, nie tylko dla komputerów
      4. 34.4. Programuj do języka, a nie w nim
      5. 34.5. Konwencje jako pomoc w koncentracji uwagi
      6. 34.6. Programowanie w kategoriach dziedziny problemu
        1. Dzielenie programu na poziomy abstrakcji
          1. Poziom 0 — operacje systemowe i instrukcje maszynowe
          2. Poziom 1 — struktury i narzędzia języka programowania
          3. Poziom 2 — niskopoziomowe struktury implementacji
          4. Poziom 3 — niskopoziomowe pojęcia dziedziny problemu
          5. Poziom 4 — wysokopoziomowe pojęcia dziedziny problem
        2. Niskopoziomowe metody pracy z dziedziną problemu
      7. 34.7. Uwaga, spadające odłamki!
      8. 34.8. Iteruj, iteruj i jeszcze raz iteruj
      9. 34.9. Nie będziesz łączył religii z programowaniem
        1. Wyrocznie
        2. Eklektyzm
        3. Eksperymenty
      10. Podsumowanie
    5. 35. Gdzie znaleźć więcej informacji
      1. 35.1. Programowanie
      2. 35.2. Szersze spojrzenie na budowę oprogramowania
        1. Zagadnienia ogólne
        2. Inżynieria oprogramowania
        3. Inne bibliografie
      3. 35.3. Periodyki
        1. Popularne magazyny dla programistów
        2. Poważne czasopisma dla programistów
        3. Publikacje specjalistyczne
          1. Publikacje branżowe
          2. Wydawnictwa popularne
      4. 35.4. Plan czytelniczy programisty
        1. Poziom wstępny
        2. Poziom praktyka
        3. Poziom profesjonalisty
      5. 35.5. Stowarzyszenia zawodowe
  16. A. Bibliografia
  17. B. Steve McConnell
  18. Indeks
  19. About the Author
  20. Copyright