Diagnostyka, czyli jak naprawiać zabawki

W niniejszym rozdziale skupiamy się na wykrywaniu i usuwaniu błędów z kodu źródłowego. Jest on rozszerzeniem rozdziału o środowisku wykonawczym i edycyjnym, lecz lektura wymaga znajomości typów danych i instrukcji sterujących. Techniki i umiejętności przedstawione w tym rozdziale są wtórne: nie byłyby potrzebne, gdyby nie ludzka omylność. Dlatego warto je opanować.

Błędy

W idealnym przypadku algorytm zapisany jakimkolwiek sposobem realizuje zamiar jego twórcy. W praktyce nikt nie jest nieomylny, dlatego mamy do czynienia z różnego rodzaju błędami. Oto ich podstawowa klasyfikacja:

błędy składniowe (syntax errors)

mają miejsce, kiedy w opisie postępowania zostanie użyta nielegalna konstrukcja, np. wyrażenie arytmetyczne niezgodne z regułami budowy takich wyrażeń, fragment sieci działań zbudowany niezgodnie z regułami jej rysowania, czy też instrukcja języka programowania zapisana niezgodnie z regułami tego języka. Błędy takie uniemożliwiają realizację przetwarzania. Są one dość łatwe do wykrycia.

błędy logiczne, czyli rzeczowe (logical errors)

mają miejsce w sytuacji, kiedy schemat postępowania opisany algorytmem nie jest zgodny z jego specyfikacją. Znaczy to, że algorytm prowadzi do innych wyników, niż zamierzono. Błędów tego rodzaju nie da się wykryć automatycznie.

błędy czasu wykonania (runtime errors)

mają miejsce, kiedy na skutek nieprzewidzianych okoliczności zajdzie próba wykonania niedozwolonej operacji, np. dzielenia przez zero, obliczenia pierwiastka z liczby ujemnej lub czytania danych z nieistniejącego pliku. Błędy czasu wykonania powstają — jak sama nazwa wskazuje — w toku realizacji przetwarzania, przy czym uniemożliwiają otrzymanie danych wynikowych. Źródłem błędów tego typu mogą być m.in.: błędy logiczne w schemacie przetwarzania, użycie algorytmu w stosunku do danych nie spełniających założeń wstępnych, czy też brak gwarancji zatrzymania algorytmu. Dopracowane algorytmy użytkowe powinny być w miarę możliwości zabezpieczone przed powstawaniem błędów tego typu; w nowo opracowywanych schematach i tworzonym na ich podstawie kodzie są one w praktyce nieuniknione.

Unikanie i eliminacja błędów są poważnymi wyzwaniami związanymi z budową i opisem schematów przetwarzania. Dla ich realizacji podejmuje się działania na różnych poziomach.

Weryfikacja algorytmu polega na zbadaniu, czy robi on to, co robić powinien z punktu widzenia specyfikacji danych, tzn. czy jest skuteczny. Analiza taka wymaga pracy intelektualnej nad schematem działania algorytmu. Jest to zatem czynność, którą musi wykonywać podmiot myślący, a nie automat.

Testowanie polega na badaniu, czy wyniki podawane przez schemat przetwarzania są takie, jak powinny być, tzn. zgodne z deklarowanym celem działania algorytmu. Dlatego należałoby znać wyniki, jakich oczekuje się dla używanych przez siebie zestawów danych testowych.

Użytkowanie algorytmu polega na przygotowywaniu dla niego danych, zlecaniu komuś (np. automatowi) jego wykonania, i odbieraniu wyników, które następnie można wykorzystywać. Najczęściej użytkuje się nie tyle abstrakcyjną postać algorytmu, co opracowany na jego podstawie program. Użytkowanie programu zawierającego błędy logiczne nie ma sensu, gdyż otrzymywane wyniki są bezwartościowe.

W trakcie użytkowania kodu ujawniają się niewykryte do tej pory błędy. Mogą się też pojawić nowe potrzeby ze strony użytkowników. Dla całokształtu działań mających na celu eliminację błędów oraz rozbudowę i wszelkiego rodzaju usprawnienia, używa się terminu konserwacja algorytmu i/lub realizującego go programu.

Wspomaganie zarządzania kodem źródłowym

Wystarczy jedno użycie edytora programisty, by zauważyć, że jest on wyposażony w funkcje ułatwiające tworzenie i kontrolowanie kodu źródłowego. Dlatego właśnie warto z takich narzędzi korzystać. Zakres i sposób realizacji tych ułatwień jest nieco inny w każdym środowisku. Możliwe więc, że używany przez Ciebie edytor zachowuje się nieco inaczej, niż w poniższym opisie.

Ułatwienia wizualnej kontroli poprawności składniowej

Wizualizacja dopasowania nawiasów otwierających i zamykających. Po ustawieniu kursora na nawiasie, odpowiadający mu przeciwległy nawias jest wyróżniany barwą lub krojem pisma.

Wizualizacja elementów składni języka: słów kluczowych, komentarzy, instrukcji, wartości — np. za pomocą barw i kroju pisma.

Rozwijanie i zwijanie elementów blokowych składni (komentarzy, podprogramów, bloków instrukcji podrzędnych). Elementy blokowe mogą być wizualnie ujęte w ramki z przyciskiem umożliwiającym ukrywanie i rozwijanie.

Pomoc podczas tworzenia kodu źródłowego

Automatyzacja wcięć kodu źródłowego podczas pisania instrukcji: bieżąca głębokość wcięcia jest utrzymywana po utworzeniu nowego wiersza; po użyciu klawisza BackSpace, kiedy kursor znajduje się na początku instrukcji, następuje powrót do poprzedniej głębokości wcięć.

Zwiększanie i zmniejszanie głębokości wcięcia zaznaczonego bloku, np. za pomocą klawiszy Tab i Shift Tab.

Podpowiedzi słów w trakcie pisania: rozwijanie listy słów kluczowych, funkcji standardowych, dostępnych zmiennych, metod itp.; klawisz Enter lub Tab powoduje wstawienie słowa z listy do tekstu programu.

Podpowiedzi składni poleceń (funkcji, metod, klas) w trakcie tworzenia kodu; klawisz Enter lub Tab powoduje wstawienie słowa z listy do tekstu programu.

Automatyczne kończenie fraz składniowych języka: w Pythonie rzadko stosowane, bo frazy składniowe tego języka, z wyjątkiem nawiasów i cudzysłowów, nie wymagają zakończenia.

Debuggery i kontrolowane uruchamianie programów

Wykrywanie błędów logicznych i eliminowanie ich z kodu źródłowego jest bardzo istotnym etapem tworzenia programu. W procesie tym pomocne są narzędzia pozwalające symulować wykonywanie programu, przerwać je lub wznowić w dowolnej chwili i szczegółowo badać stan pamięci. Narzędzia takie noszą nazwę debuggerów (odpluskwiaczy).

Do najważniejszych operacji dostępnych za pomocą debuggerów należą:

1. tryb pracy krokowej polegający na wykonywaniu instrukcji z pliku źródłowego wiersz po wierszu (Step over, Step into);
2. ustawianie pułapek (breakpoints) wymuszających wstrzymanie wykonywania programu przed wskazaną instrukcją. W środowiskach programistycznych pułapka bywa ona często oznaczana czerwoną linią lub czerwonym znaczkiem przy instrukcji;
3. wgląd w wartości zmiennych (watch, podgląd, czujki) przechowywanych w pamięci oraz wyrażeń z nich korzystających;
4. możliwość zmiany stanu zmiennej (Evaluate, Modify)
5. oraz wiele innych możliwości.

W kolejnych sekcjach krótko omówimy podstawową metodykę diagnozowania kodu źródłowego. Diagnozowany program musi być poprawny pod względem składniowym; w przeciwnym razie jego uruchomienie nie będzie możliwe.

Praca krokowa

Domyślnie program jest uruchamiany w trybie ciągłym (non stop mode, go, run), tak samo jak bez użycia debuggera.

W trybie pracy krokowej po wykonaniu każdej instrukcji, ew. każdego wiersza kodu źródłowego, praca jest wstrzymywana. Niektóre debuggery mają kilka trybów pracy krokowej. Różnią się one traktowaniem podprogramów: albo wywołują je w jednym kroku (step over), albo instrukcja po instrukcji (step into).

W nowoczesnych debuggerach wysokiej klasy oferowana jest nawet funkcja kroku wstecz, czyli anulowania skutków ostatnio wykonanej instrukcji (o ile w odniesieniu do pamięci programu jest to możliwe, nie sposób wyobrazić sobie cofnięcia wykonanej operacji systemowej, takiej jak nadpisanie pliku lub przesłanie wydruku do urządzenia).

Przejście z trybu krokowego do trybu ciągłego jest możliwe w dowolnym momencie (go, continue).

Niektóre debuggery mają też funkcję wymuszającą natychmiastowe przejście z trybu ciągłego w tryb krokowy (break). Przy tej metodzie nie sposób przewidzieć, przy której instrukcji program zostanie wstrzymany; zależy to m.in. od chwili, w której zażądano przerwania pracy.

Pułapki

Pułapki (breakpoints) są miejscami w kodzie źródłowym, po dojściu do których wykonywanie programu w trybie ciągłym ma zostać wstrzymane.

Na ogół pułapki są ustawiane za pomocą funkcji menu lub skrótów klawiatury, a ich lokalizacja jest czytelnie oznaczona (np. na marginesie edytora lub przez wyróżnienie wiersza kodu).

Inny wariant ustawiania pułapek wykorzystuje położenie kursora w edytorze kodu źródłowego w chwili uruchomienia programu (go to cursor).

Podgląd

Podgląd zawartości zmiennych i wyrażeń (Watch, ‘czujki’) pozwala wizualnie badać stan pamięci i konfrontować go z zamiarami autora programu. Jest to narzędzie pomocne przy wykrywaniu uporczywych błędów, a także nieocenione w procesie nauki programowania.

Konsola / modyfikacje stanu

W większości debuggerów Pythona konsola interaktywna jest do dyspozycji operatora. Da się z niej korzystać w trybie krokowym lub po przerwaniu trybu ciągłego.

Pierwszy sposób jej wykorzystania wiąże się z kontrolą wartości wyrażeń. Jest to funkcja zbliżona do tej oferowanej przez podgląd pamięci programu.

Druga możliwość użycia konsoli interpretera wiąże się z modyfikacją obiektów programu.

Co i w jakiej kolejności sprawdzać

Dobrym nawykiem jest narzucenie takiego stylu pracy, w którym dbałość o poprawność logiczną jest stałym elementem. Pełne omówienie tego tematu nie jest możliwe w krótkich ramach tego kursu. Ale kilka podstawowych reguł warto znać:

1. Pamiętaj, że kod źródłowy jest odzwierciedleniem algorytmu, a ten z kolei — sposobem na niezawodne uzyskanie danych wynikowych. Zatem zanim zaczniesz cokolwiek pisać, musisz znać swój cel. Dotyczy to nie tylko całości pracy, ale każdego jej etapu.
2. Twórz schematy blokowe i opisy nieformalne, zanim rozpoczniesz pisanie kodu.
3. Dziel dużą pracę na etapy. Używaj podprogramów do ich realizacji.
4. Testuj podprogramy na możliwie różnorodnych zestawach danych, nawet nie związanych bezpośrednio z Twoim problemem.
5. Dbaj o poprawność logiczną i składniową na każdym etapie pracy:
   • w skali mikro znaczy to: opracuj działający schemat dla szczególnego przypadku i uogólniaj go zgodnie z logiką (metoda wstępująca);
   • w skali makro znaczy to: stwórz makietę, która chociaż „nic nie robi”, to zawiera gotowy schemat logiczny całości nadający się do testowania; następnie stopniowo wypełniaj ją szczegółami (metoda zstępująca);
   • nie przepisuj programu jak tekstu, od początku do końca. Przyjmij taką kolejność, żeby w każdym momencie program — mimo że nieukończony — był poprawny składniowo i dzięki temu dawał się uruchomić.
6. Ukrywaj szczegóły w podprogramach. Nadawaj obiektom nazwy związane z ich przeznaczeniem. Staraj się, by lektura kodu pozwalała na zrozumienie, jaki jest cel Twojej pracy.
7. Wykorzystuj posiadane podprogramy wszędzie, gdzie to możliwe.
8. Pisz komentarze. Kiedy wrócisz do tego samego miejsca za parę tygodni, okażą się nieocenione.
9. Na czas układania kodu twórz wydruki kontrolne za pomocą funkcji print i używaj debuggerów do sprawdzania pośrednich etapów obliczeń. Konfrontuj je z wynikami, jakie uważasz za poprawne.
10. Od czasu do czasu, tam gdzie to możliwe, postaw się w roli procesora i samodzielnie przeprowadź obliczenia dokładnie według napisanych w kodzie instrukcji.