• Jak tworzyć oprogramowanie, które łatwo się debuguje?
• Jak wykrywać potencjalne przyczyny problemów?
• Jak ominąć pułapki czyhające na programistów?

Zapewne niejednokrotnie podczas pracy przy komputerze musiałeś użerać się z wadliwymi aplikacjami. Doskonale wiesz, jak to jest, kiedy kolejne łatki usuwają stare błędy, równocześnie generując nowe, programiści zaś nie kwapią się do zmiany niewłaściwych założeń. A przecież jednym z najbardziej niedocenianych aspektów profesjonalnego programowania jest zdolność do rozpoznawania i usuwania błędów kryjących się w każdej większej partii stworzonego kodu. Jeśli tworzysz niebanalne aplikacje, najprawdopodobniej zajmiesz się ich debugowaniem chwilę po zakończeniu ich pisania. To zajęcie w zdecydowanie większym stopniu niż inne aspekty tworzenia oprogramowania jest działalnością intelektualną - ponieważ jego areną jest umysł programisty. Znajdowanie i wyjaśnianie przyczyn problemów powinno być pierwszą czynnością na drodze do ich zwalczania.

Ta książka poświęcona jest właśnie arkanom sztuki debugowania. Jej lektura pozwoli Ci znacznie ograniczyć liczbę popełnianych błędów, a te, które się pojawią, będą łatwiejsze do wykrycia i usunięcia. Podręcznik wyjaśni Ci, jak pisać kod, który łatwo debugować, przeprowadzi Cię przez proces wykrywania błędów, ich reprodukcji, diagnozowania, aż do wprowadzania i wycofywania poprawek w oprogramowaniu. Poznaj empiryczną metodę wykrywania błędów. Dowiedz się, jak ważne jest zapewnienie sobie pewnych sposobów reprodukowania błędnych zachowań. Naucz się unikać pułapek czyhających zarówno na programistów, jak i testerów. Stosuj powszechnie używane narzędzia i metody zapewniające automatyczne wykrywanie potencjalnych przyczyn problemów, zanim jeszcze się one pojawią! Naucz się tworzyć samodebugujące oprogramowanie, które automatycznie informuje o swoim stanie, a także sprawdź, co możesz zrobić, aby szybko wykrywać sytuacje będące potencjalną przyczyną problemów.

• Metoda empiryczna
• Reprodukcja błędów
• Diagnozowanie
• Wyszukiwanie błędów
• Wprowadzanie i wycofywanie poprawek
• Testowanie
• Przyczyny błędów
• Oprogramowanie samodebugujące
• Narzędzia wspomagające

Osoby które kupowały "Debugowanie. Jak wyszukiwać i naprawiać błędy w kodzie oraz im zapobiegać", wybierały także:

• F# 4.0 dla zaawansowanych. Wydanie IV 96,45 zł, (29,90 zł -69%)
• Systemy reaktywne. Wzorce projektowe i ich stosowanie 65,31 zł, (20,90 zł -68%)
• Scratch. Komiksowa przygoda z programowaniem 36,06 zł, (11,90 zł -67%)
• GameMaker. Kurs video. Kompleksowy przewodnik tworzenia gier platformowych 154,58 zł, (55,65 zł -64%)
• Dost 89,00 zł, (35,60 zł -60%)

Spis treści

Debugowanie. Jak wyszukiwać i naprawiać błędy w kodzie oraz im zapobiegać -- spis treści

Od tłumacza słów kilka (9)

Przedmowa (13)

Część I. Istota problemu

Rozdział 1. W tym szaleństwie jest metoda (19)

• 1.1. Debugowanie to coś więcej niż eksterminacja błędów (20)
• 1.2. Metoda empiryczna (22)
• 1.3. Struktura procesu debugowania (23)
• 1.4. Przede wszystkim rzeczy najważniejsze (24)
• 1.5. Do dzieła! (28)

Rozdział 2. Reprodukcja (29)

• 2.1. Najpierw reprodukcja, potem pytania (29)
• 2.2. Kontrolowane zachowanie aplikacji (32)
• 2.3. Kontrolowane środowisko (32)
• 2.4. Kontrolowane dane wejściowe (34)
• 2.5. Ulepszanie reprodukcji (43)
• 2.6. Gdy błąd nie chce się ujawnić (52)
• 2.7. Podsumowanie (55)

Rozdział 3. Diagnoza (57)

• 3.1. Gdy debugowanie staje się nauką (57)
• 3.2. Sztuczki i chwyty (63)
• 3.3. Debuggery (70)
• 3.4. Pułapki (71)
• 3.5. Gry umysłowe (76)
• 3.6. Zweryfikuj swoją diagnozę (80)
• 3.7. Podsumowanie (81)

Rozdział 4. Poprawki (83)

• 4.1. Czysta tablica (84)
• 4.2. Testowanie (85)
• 4.3. Eliminowanie przyczyn, nie objawów (87)
• 4.4. Refaktoryzacja (89)
• 4.5. Kontrola wersji (91)
• 4.6. Inspekcja kodu (92)
• 4.7. Podsumowanie (93)

Rozdział 5. Refleksja (95)

• 5.1. Jak to w ogóle mogło działać? (95)
• 5.2. Co poszło nie tak? (97)
• 5.3. Nigdy więcej tego samego błędu (99)
• 5.4. Zamykanie pętli (102)
• 5.5. Podsumowanie (102)

Część II. Szersza perspektywa

Rozdział 6. Chyba mamy problem... (105)

• 6.1. Tropienie błędów (106)
• 6.2. Współpraca z użytkownikami (109)
• 6.3. Współdziałanie z innymi zespołami (116)
• 6.4. Podsumowanie (117)

Rozdział 7. Pragmatyczna nietolerancja (119)

• 7.1. Błędy mają pierwszeństwo (119)
• 7.2. Debugowanie a psychologia (122)
• 7.3. Zasypywanie przepaści jakościowej (125)
• 7.4. Podsumowanie (129)

Część III. Debug-Fu

Rozdział 8. Przypadki szczególne (133)

• 8.1. Łatanie istniejącego oprogramowania (133)
• 8.2. Kompatybilność wersji (134)
• 8.3. Współbieżność (139)
• 8.4. Błędy heisenbergowskie (142)
• 8.5. Problemy z wydajnością (144)
• 8.6. Systemy osadzone (147)
• 8.7. Błędy w obcym oprogramowaniu (150)
• 8.8. Podsumowanie (154)

Rozdział 9. Idealne środowisko debugowania (155)

• 9.1. Automatyczne testowanie (155)
• 9.2. Kontrola wersji (158)
• 9.3. Automatyczne budowanie binariów (163)
• 9.4. Podsumowanie (171)

Rozdział 10. Naucz swe oprogramowanie samodebugowania (173)

• 10.1. Założenia i asercje (174)
• 10.2. Binaria debugowalne (184)
• 10.3. Wycieki zasobów i błędna obsługa wyjątków (189)
• 10.4. Podsumowanie (195)

Rozdział 11. Antywzorce (197)

• 11.1. Inflacja priorytetów (197)
• 11.2. Primadonna (198)
• 11.3. Zespół serwisowy (200)
• 11.4. Gaszenie pożaru (202)
• 11.5. Pisanie od nowa (203)
• 11.6. Bezpański kod (205)
• 11.7. Czarna magia (206)
• 11.8. Podsumowanie (207)

Dodatki

Dodatek A: Materiały (211)

• A.1. Systemy kontroli wersji i śledzenia problemów (211)
• A.2. Narzędzia zarządzania generowaniem binariów i integracją ciągłą (215)
• A.3. Przydatne biblioteki (216)
• A.4. Inne narzędzia (218)

Skorowidz (223)