Szczegóły ebooka

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

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

Steve McConnell

Ebook

Kultowy podręcznik tworzenia doskonałego oprogramowania!

  • Twórz wolny od błędów, najwyższej jakości kod
  • Utrzymuj stałą kontrolę nad złożonymi projektami
  • Wcześnie wykrywaj i rozwiązuj problemy
  • Sprawnie rozwijaj i poprawiaj oprogramowanie

Steve McConnell wie więcej o budowie oprogramowania niż ktokolwiek inny; mamy ogromne szczęście, że zdecydował się podzielić swoim doświadczeniem oraz wiedzą w tej ważnej i oryginalnej książce.

Alan Cooper, „ojciec” języka Visual Basic, autor książki About Face

Zapewne każdy zgodzi się ze stwierdzeniem, że jeśli jakiś proces odpowiada za nawet 70% błędów w gotowym produkcie, z pewnością wymaga znaczącego usprawnienia... Czy masz jednak świadomość, że właśnie tyle problemów generuje samo wytwarzanie oprogramowania? Te błędy powodują nie tylko usterki w już gotowych programach, niespełniających oczekiwań klientów — odpowiadają także za znaczne opóźnienia przy realizacji zleconych projektów i nagminne przekraczanie zaplanowanego budżetu. Każdy ambitny programista staje zatem przed koniecznością zdobycia wiedzy o takich metodach pracy, które pozwolą szybciej i efektywniej realizować projekty, a przy tym zapewniać najwyższą jakość tworzonego kodu. W końcu na podstawie tych właśnie umiejętności oceniana jest także wartość danego programisty w zespole.

Z tych właśnie powodów niniejsza książka, będąca przejrzystą kompilacją najlepszych technik programowania, zdobyła tak wielkie uznanie w środowisku zawodowców i studentów, osiągając miano podręcznika kultowego. Przed Tobą drugie, zaktualizowane wydanie słynnej publikacji, w której Steve McConnell przedstawia wszystkie aspekty budowy programów, takie jak jakość czy podejście do procesu wytwarzania. Autor rozwija tu tak istotne zagadnienia, jak przebieg budowy klasy, techniki pracy z danymi i strukturami sterującymi, debugowanie, refaktoryzowanie oraz metody i strategie optymalizacji. Znajdziesz tu dziesiątki list kontrolnych, pomocnych w ocenianiu architektury, jakości klas i procedur, nazw zmiennych czy struktur sterujących, a także ponad 500 przykładów dobrego i złego kodu. Dowiesz się, co było przyczyną wielu typowych problemów w przeszłości i jak ich dzisiaj unikać. Opisane metody pracy pomogą utrzymać kontrolę nad dużymi projektami oraz efektywnie rozwijać i modyfikować oprogramowanie w odpowiedzi na zmiany wymagań. Co ważne, można je skutecznie wykorzystywać niezależnie od stosowanego języka programowania!

Dzięki tej książce nauczysz się skutecznie:
  • projektować z zachowaniem minimalnej złożoności;
  • praktycznie wykorzystywać metody pracy zespołowej;
  • programować defensywnie, by unikać błędów w kodzie i jak najszybciej je z niego usuwać;
  • wykorzystywać okazje do refaktoryzacji oraz rozwijania kodu i robić to w sposób bezpieczny;
  • korzystać z metod programowania dopasowanych do projektu;
  • szybko i efektywnie debugować;
  • wcześnie i we właściwy sposób rozwiązywać najważniejsze problemy z konstrukcją oprogramowania;
  • dbać o jakość kodu od pierwszego do ostatniego dnia projektu.

Posiądź kluczowe umiejętności tworzenia najwyższej jakości oprogramowania!

Steve McConnell jest jednym z najbardziej szanowanych ekspertów w świecie informatyki. Jest głównym programistą w firmie Construx Software oraz znanym autorem bestsellerowych książek, m.in. Kod doskonały i Rapid Development — obie zostały uhonorowane nagrodą Jolt magazynu „Software Development”, przyznawaną co roku najlepszej książce poświęconej procesowi wytwarzania oprogramowania. Brał udział w projektach realizowanych dla takich firm, jak Microsoft czy Boeing, a w 1998 roku czytelnicy magazynu „Software Development” uznali go obok Billa Gatesa i Linusa Torvaldsa za jedną z trzech najbardziej wpływowych osób w branży oprogramowania.

Wstęp (15)

Podziękowania (23)

Listy kontrolne (25)

Tabele (27)

Rysunki (29)

CZĘŚĆ I. PROCES BUDOWY OPROGRAMOWANIA (35)

1. Budowa oprogramowania (37)

  • 1.1. Czym jest budowa oprogramowania (37)
  • 1.2. Znaczenie procesu budowy oprogramowania (40)
  • 1.3. Jak korzystać z tej książki (41)

2. Metafory procesu programowania (43)

  • 2.1. Znaczenie metafor (43)
  • 2.2. Jak korzystać z metafor w programowaniu (46)
  • 2.3. Popularne metafory programowania (47)

3. Przed programowaniem - przygotowania (57)

  • 3.1. Przygotowania i ich znaczenie (58)
  • 3.2. Określanie rodzaju budowanego oprogramowania (65)
  • 3.3. Definicja problemu (70)
  • 3.4. Określenie wymagań (72)
  • 3.5. Architektura (77)
  • 3.6. Ilość czasu poświęcanego na przygotowania (89)

4. Kluczowe decyzje konstrukcyjne (95)

  • 4.1. Wybór języka programowania (95)
  • 4.2. Konwencje programowania (100)
  • 4.3. Twoje położenie na fali technologii (101)
  • 4.4. Wybór podstawowych praktyk programowania (103)

CZĘŚĆ II. PISANIE DOBREGO KODU (107)

5. Projektowanie (109)

  • 5.1. Podstawowe problemy projektowania (110)
  • 5.2. Podstawowe pojęcia projektowania (113)
  • 5.3. Heurystyki - narzędzia projektanta (122)
  • 5.4. Techniki projektowania (146)
  • 5.5. Uwagi o popularnych metodykach pracy (155)

6. Klasy z klasą (161)

  • 6.1. Abstrakcyjne typy danych (162)
  • 6.2. Dobry interfejs klasy (169)
  • 6.3. Problemy projektowania i implementacji (179)
  • 6.4. Przesłanki dla utworzenia klasy (188)
  • 6.5. Specyfika języka (192)
  • 6.6. Pakiety klas (192)

7. Procedury wysokiej jakości (197)

  • 7.1. Przesłanki utworzenia procedury (200)
  • 7.2. Projektowanie na poziomie procedur (204)
  • 7.3. Dobra nazwa procedury (207)
  • 7.4. Jak długa może być procedura? (209)
  • 7.5. Jak używać parametrów procedur (211)
  • 7.6. Używanie funkcji (217)
  • 7.7. Makra i procedury inline (218)

8. Programowanie defensywne (223)

  • 8.1. Zabezpieczanie programu przed niewłaściwymi danymi wejściowymi (224)
  • 8.2. Asercje (225)
  • 8.3. Mechanizmy obsługi błędów (230)
  • 8.4. Wyjątki (234)
  • 8.5. Ograniczanie zasięgu szkód powodowanych przez błędy (239)
  • 8.6. Kod wspomagający debugowanie (241)
  • 8.7. Ilość kodu defensywnego w wersji finalnej (245)
  • 8.8. Defensywne podejście do programowania defensywnego (246)

9. Proces Programowania w Pseudokodzie (251)

  • 9.1. Budowanie klas i procedur krok po kroku (251)
  • 9.2. Pseudokod dla zaawansowanych (253)
  • 9.3. Budowanie procedur metodą PPP (256)
  • 9.4. Alternatywy dla pseudokodu (269)

CZĘŚĆ III. ZMIENNE (273)

10. Zmienne w programie (275)

  • 10.1. Podstawowa wiedza o danych (276)
  • 10.2. Deklarowanie zmiennych (277)
  • 10.3. Inicjalizowanie zmiennych (278)
  • 10.4. Zakres (282)
  • 10.5. Trwałość (289)
  • 10.6. Czas wiązania (290)
  • 10.7. Związek między typami danych i strukturami sterowania (292)
  • 10.8. Jedno przeznaczenie każdej zmiennej (293)

11. Potęga nazwy zmiennej (297)

  • 11.1. Wybieranie dobrej nazwy (297)
  • 11.2. Nazwy a rodzaje danych (303)
  • 11.3. Potęga konwencji nazw (308)
  • 11.4. Nieformalne konwencje nazw (310)
  • 11.5. Standardowe prefiksy (317)
  • 11.6. Nazwy krótkie a czytelne (319)
  • 11.7. Nazwy, których należy unikać (322)

12. Podstawowe typy danych (327)

  • 12.1. Liczby (327)
  • 12.2. Liczby całkowite (329)
  • 12.3. Liczby zmiennoprzecinkowe (331)
  • 12.4. Znaki i ciągi znakowe (333)
  • 12.5. Zmienne logiczne (336)
  • 12.6. Typy wyliczeniowe (338)
  • 12.7. Stałe nazwane (343)
  • 12.8. Tablice (345)
  • 12.9. Tworzenie własnych typów (aliasy) (346)

13. Inne typy danych (355)

  • 13.1. Struktury (355)
  • 13.2. Wskaźniki (359)
  • 13.3. Dane globalne (371)

CZĘŚĆ IV. INSTRUKCJE (383)

14. Struktura kodu liniowego (385)

  • 14.1. Instrukcje, które wymagają określonej kolejności (385)
  • 14.2. Instrukcje, których kolejność nie ma znaczenia (388)

15. Instrukcje warunkowe (393)

  • 15.1. Instrukcje if (393)
  • 15.2. Instrukcje case (398)

16. Pętle (405)

  • 16.1. Wybieranie rodzaju pętli (405)
  • 16.2. Sterowanie pętlą (410)
  • 16.3. Łatwe tworzenie pętli - od wewnątrz (422)
  • 16.4. Pętle i tablice (424)

17. Nietypowe struktury sterowania (427)

  • 17.1. Wiele wyjść z procedury (427)
  • 17.2. Rekurencja (429)
  • 17.3. Instrukcja goto (434)
  • 17.4. Nietypowe struktury sterowania z perspektywy (444)

18. Metody oparte na tabelach (449)

  • 18.1. Metody oparte na tabelach - wprowadzenie (449)
  • 18.2. Tabele o dostępie bezpośrednim (451)
  • 18.3. Tabele o dostępie indeksowym (462)
  • 18.4. Tabele o dostępie schodkowym (464)
  • 18.5. Inne metody wyszukiwania w tabelach (467)

19. Ogólne problemy sterowania (469)

  • 19.1. Wyrażenia logiczne (469)
  • 19.2. Instrukcje złożone (bloki) (480)
  • 19.3. Instrukcje puste (481)
  • 19.4. Praca z głębokimi zagnieżdżeniami (482)
  • 19.5. Programowanie strukturalne (490)
  • 19.6. Struktury sterujące i złożoność (493)

CZĘŚĆ V. SPRAWNA PRACA Z KODEM (497)

20. Jakość oprogramowania (499)

  • 20.1. Składowe jakości (499)
  • 20.2. Metody podwyższania jakości (502)
  • 20.3. Skuteczność metod podwyższania jakości (505)
  • 20.4. Kiedy przeprowadzać kontrolę jakości (509)
  • 20.5. Ogólna Zasada Jakości Oprogramowania (509)

21. Programowanie zespołowe (513)

  • 21.1. Przegląd metod programowania zespołowego (514)
  • 21.2. Programowanie w parach (517)
  • 21.3. Formalne inspekcje (519)
  • 21.4. Inne metody programowania zespołowego (526)

22. Testowanie (533)

  • 22.1. Rola testów programisty (534)
  • 22.2. Zalecane podejście do testów programisty (537)
  • 22.3. Praktyczne techniki testowania (539)
  • 22.4. Typowe błędy (550)
  • 22.5. Narzędzia wspomagające testowanie (556)
  • 22.6. Usprawnianie testów (561)
  • 22.7. Gromadzenie informacji o testach (563)

23. Debugowanie (569)

  • 23.1. Wprowadzenie (569)
  • 23.2. Wyszukiwanie defektu (574)
  • 23.3. Usuwanie defektu (585)
  • 23.4. Debugowanie a psychologia (588)
  • 23.5. Narzędzia debugowania - oczywiste i mniej oczywiste (591)

24. Refaktoryzacja (597)

  • 24.1. Ewolucja oprogramowania i jej odmiany (598)
  • 24.2. Refaktoryzacje - wprowadzenie (599)
  • 24.3. Wybrane refaktoryzacje (605)
  • 24.4. Bezpieczne przekształcanie kodu (613)
  • 24.5. Strategie refaktoryzacji (615)

25. Strategie optymalizacji kodu (621)

  • 25.1. Wydajność kodu (622)
  • 25.2. Optymalizowanie kodu (625)
  • 25.3. Rodzaje otyłości i lenistwa (632)
  • 25.4. Pomiary (637)
  • 25.5. Iterowanie (639)
  • 25.6. Strategie optymalizacji kodu - podsumowanie (640)

26. Metody optymalizacji kodu (645)

  • 26.1. Struktury logiczne (646)
  • 26.2. Pętle (651)
  • 26.3. Przekształcenia danych (660)
  • 26.4. Wyrażenia (665)
  • 26.5. Procedury (674)
  • 26.6. Reimplementacja w języku niskiego poziomu (675)
  • 26.7. Im bardziej świat się zmienia, tym więcej zostaje bez zmian (677)

CZĘŚĆ VI. ŚRODOWISKO PROGRAMOWANIA (681)

27. Jak rozmiar programu wpływa na jego budowę (683)

  • 27.1. Wielkość projektu a komunikacja (684)
  • 27.2. Skala rozmiarów projektów (684)
  • 27.3. Wpływ wielkości projektu na liczbę błędów (685)
  • 27.4. Wpływ wielkości projektu na efektywność pracy (687)
  • 27.5. Wpływ wielkości projektu na wykonywaną pracę (687)

28. Zarządzanie w programowaniu (695)

  • 28.1. Zachęcanie do budowy dobrego kodu (696)
  • 28.2. Zarządzanie konfiguracją (698)
  • 28.3. Budowanie harmonogramu (705)
  • 28.4. Pomiary (712)
  • 28.5. Ludzkie traktowanie programistów (715)
  • 28.6. Współpraca z przełożonymi (721)

29. Integracja (725)

  • 29.1. Znaczenie metod integracji (725)
  • 29.2. Częstość integracji - końcowa czy przyrostowa? (727)
  • 29.3. Przyrostowe strategie integracji (730)
  • 29.4. Codzienna kompilacja i test dymowy (738)

30. Narzędzia programowania (747)

  • 30.1. Narzędzia do projektowania (748)
  • 30.2. Narzędzia do pracy z kodem źródłowym (748)
  • 30.3. Narzędzia do pracy z kodem wykonywalnym (754)
  • 30.4. Środowiska narzędzi programowania (758)
  • 30.5. Budowanie własnych narzędzi (759)
  • 30.6. Narzędzia przyszłości (761)

CZĘŚĆ VII. RZEMIOSŁO PROGRAMISTY (765)

31. Układ i styl (767)

  • 31.1. Wprowadzenie (768)
  • 31.2. Techniki formatowania (774)
  • 31.3. Style formatowania (776)
  • 31.4. Formatowanie struktur sterujących (782)
  • 31.5. Formatowanie instrukcji (789)
  • 31.6. Formatowanie komentarzy (800)
  • 31.7. Formatowanie procedur (802)
  • 31.8. Formatowanie klas (804)

32. Kod, który opisuje się sam (813)

  • 32.1. Zewnętrzna dokumentacja programu (813)
  • 32.2. Styl programowania jako dokumentacja (814)
  • 32.3. Komentować czy nie komentować (817)
  • 32.4. Zasady pisania dobrych komentarzy (821)
  • 32.5. Metody pisania komentarzy (828)
  • 32.6. Normy IEEE (849)

33. Cechy charakteru (855)

  • 33.1. Czy osobowość jest bez znaczenia? (856)
  • 33.2. Inteligencja i skromność (857)
  • 33.3. Ciekawość (858)
  • 33.4. Uczciwość intelektualna (862)
  • 33.5. Komunikacja i współpraca (865)
  • 33.6. Kreatywność i dyscyplina (865)
  • 33.7. Lenistwo (866)
  • 33.8. Cechy, które znaczą mniej, niż myślisz (867)
  • 33.9. Nawyki (869)

34. Powracające wątki - przegląd (873)

  • 34.1. Walka ze złożonością (873)
  • 34.2. Wybierz swój proces (875)
  • 34.3. Pisz programy dla ludzi, nie tylko dla komputerów (877)
  • 34.4. Programuj do języka, a nie w nim (879)
  • 34.5. Konwencje jako pomoc w koncentracji uwagi (880)
  • 34.6. Programowanie w kategoriach dziedziny problemu (881)
  • 34.7. Uwaga, spadające odłamki! (884)
  • 34.8. Iteruj, iteruj i jeszcze raz iteruj (886)
  • 34.9. Nie będziesz łączył religii z programowaniem (887)

35. Gdzie znaleźć więcej informacji (891)

  • 35.1. Programowanie (892)
  • 35.2. Szersze spojrzenie na budowę oprogramowania (893)
  • 35.3. Periodyki (895)
  • 35.4. Plan czytelniczy programisty (896)
  • 35.5. Stowarzyszenia zawodowe (898)

Bibliografia (899)

Skorowidz (918)

  • Tytuł: Kod doskonały. Jak tworzyć oprogramowanie pozbawione błędów. Wydanie II
  • Autor: Steve McConnell
  • Tytuł oryginału: Code Complete: A Practical Handbook of Software Construction, Second Edition
  • ISBN: 978-83-283-3490-8, 9788328334908
  • Data wydania: 2010-11-02
  • Format: Ebook
  • Identyfikator pozycji: koddov
  • Wydawca: Helion