Twój koszyk : Do zapłaty 0,00 zł Ilość w koszyku: 0

Strona główna » informatyka » Programowanie » Inżynieria oprogramowania

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!

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)