Lekcja programowania. Najlepsze praktyki
Autorzy: Brian W. Kernighan, Rob Pike
Data wydania: 2011/08
Stron: 272
    Tytuł oryginału: The Practice of Programming
    Tłumaczenie: Łukasz Piwko
    ISBN: 978-83-246-3226-8
    Format: 172x245
    Oprawa: twarda
    Numer z katalogu: 6625
Wydawnictwo Helion

ftp://ftp.helion.pl/przyklady/prapro.zip

Twórz zgodnie z trzema zasadami stanowiącymi kanon dobrego oprogramowania

    Prostota - czyli kod prosty i łatwy w obsłudze
    Ogólność - czyli kod działający dobrze w różnych sytuacjach i adaptujący się do nowych warunków
    Przejrzystość - czyli kod łatwy do zrozumienia zarówno przez ludzi, jak i maszyny

Czy zdarzyło Ci się kiedykolwiek…

    pominąć oczywisty błąd w programie i spędzić cały dzień na szukaniu go?
    próbować wprowadzić sensowne zmiany w programie napisanym przez kogoś innego?
    przepisać program od nowa, bo nie dało się go zrozumieć?

Jeśli tak, w przyszłości na pewno chciałbyś tego uniknąć! Takie problemy dla zbyt wielu programistów są niestety chlebem powszednim. Dzieje się tak między innymi dlatego, że testowanie, diagnostyka, przenośność, wydajność czy styl programowania są często traktowane po macoszemu przez osoby tworzące oprogramowanie. A świat rządzony przez olbrzymie interfejsy, wciąż zmieniające się narzędzia, języki czy systemy nie sprzyja podstawowym zasadom tworzenia dobrego kodu - prostocie, ogólności i przejrzystości.

Programowanie to coś więcej niż samo pisanie kodu. W książce "Lekcja programowania. Najlepsze praktyki" znajdziesz opis wszystkich zagadnień, z którymi styka się programista - od projektowania, poprzez usuwanie usterek, testowanie kodu czy poprawę jego wydajności, po problemy związane z poprawianiem oprogramowania napisanego przez innych. Wszystko zostało oparte na zaczerpniętych z realnych projektów przykładach, napisanych w językach C, C++, Java i innych.

Tylko tutaj znajdziesz omówienia następujących zagadnień:

    Styl: pisanie kodu, który dobrze działa i przyjemnie się czyta
    Projektowanie: wybór algorytmów i struktur danych najlepiej nadających się do określonego zadania
    Interfejsy: kontrolowanie relacji między składnikami programów
    Usuwanie błędów: szybkie i metodyczne wyszukiwanie błędów
    Testowanie: zapewnianie niezawodności i poprawności oprogramowania
    Wydajność: maksymalizowanie szybkości działania programów
    Przenośność: pisanie programów, które działają wszędzie bez żadnych zmian
    Notacja: wybór języków i narzędzi, które pozwalają maszynie zrobić więcej

Stwórz swój własny kod w najlepszym stylu!

Spis treści:

Wstęp (7)
1. Styl (11)

    1.1. Nazwy (13)
    1.2. Wyrażenia i instrukcje (16)
    1.3. Spójność i idiomy (20)
    1.4. Makra w roli funkcji (28)
    1.5. Liczby magiczne (29)
    1.6. Komentarze (33)
    1.7. Dlaczego warto dbać o styl? (38)

2. Algorytmy i struktury danych (39)

    2.1. Przeszukiwanie (40)
    2.2. Sortowanie (42)
    2.3. Biblioteki (44)
    2.4. Sortowanie szybkie w Javie (47)
    2.5. Notacja O (50)
    2.6. Tablice rozszerzalne (51)
    2.7. Listy (54)
    2.8. Drzewa (59)
    2.9. Tablice mieszania (64)
    2.10. Podsumowanie (68)

3. Projektowanie i implementacja (69)

    3.1. Algorytm łańcucha Markowa (70)
    3.2. Wybór struktury danych (72)
    3.3. Budowa struktury danych w języku C (73)
    3.4. Generowanie tekstu (77)
    3.5. Java (79)
    3.6. C++ (83)
    3.7. Awk i Perl (86)
    3.8. Wydajność (88)
    3.9. Wnioski (89)

4. Interfejsy (93)

    4.1. Wartości oddzielane przecinkami (94)
    4.2. Prototyp biblioteki (95)
    4.3. Biblioteka dla innych (99)
    4.4. Implementacja w języku C++ (108)
    4.5. Zasady projektowania interfejsów (112)
    4.6. Zarządzanie zasobami (114)
    4.7. Obsługa błędów (117)
    4.8. Interfejsy użytkownika (121)

5. Usuwanie błędów (125)

    5.1. Programy diagnostyczne (126)
    5.2. Dobre pomysły, łatwe błędy (127)
    5.3. Brak pomysłów, trudne błędy (131)
    5.4. Ostatnia deska ratunku (135)
    5.5. Błędy niepowtarzalne (138)
    5.6. Narzędzia diagnostyczne (140)
    5.7. Błędy popełnione przez innych (143)
    5.8. Podsumowanie (144)

6. Testowanie (147)

    6.1. Testuj kod podczas jego pisania (148)
    6.2. Systematyczne testowanie (153)
    6.3. Automatyzacja testów (157)
    6.4. Ramy testowe (159)
    6.5. Testowanie przeciążeniowe (163)
    6.6. Porady dotyczące testowania (166)
    6.7. Kto zajmuje się testowaniem (167)
    6.8. Testowanie programu markov (168)
    6.9. Podsumowanie (170)

7. Wydajność (171)

    7.1. Wąskie gardło (172)
    7.2. Mierzenie czasu wykonywania i profilowanie programu (177)
    7.3. Strategie przyspieszania (181)
    7.4. Regulowanie kodu (184)
    7.5. Oszczędzanie pamięci (188)
    7.6. Szacowanie (191)
    7.7. Podsumowanie (193)

8. Przenośność (195)

    8.1. Język (196)
    8.2. Nagłówki i biblioteki (202)
    8.3. Organizacja programu (204)
    8.4. Izolacja (208)
    8.5. Wymiana danych (209)
    8.6. Kolejność bajtów (210)
    8.7. Przenośność a uaktualnianie (213)
    8.8. Internacjonalizacja (215)
    8.9. Podsumowanie (218)

9. Notacja (221)

    9.1. Formatowanie danych (222)
    9.2. Wyrażenia regularne (228)
    9.3. Programowalne narzędzia (234)
    9.4. Interpretery, kompilatory i maszyny wirtualne (237)
    9.5. Programy, które piszą programy (242)
    9.6. Generowanie kodu za pomocą makr (246)
    9.7. Kompilacja w locie (247)

A: Epilog (253)
B: Zebrane zasady (255)
Skorowidz (259)

Autor: Kerninghan Brian, Pike Rob
Rok wydania: 2011
ISBN: 978-83-246-3226-8

Data dodania do sklepu sobota, 03 wrzesień 2011.

Możesz dodać swoją recenzję nt. produktu.