Jakub Chabik
PRAKTYKA SKUTECZNEGO PROGRAMOWANIA


W książce przedstawiono problemy i zadania powstające przy tworzeniu systemów informatycznych. Opisuje sposób zarządzania procesem informatycznym i zasady tworzenia łącza programowego (interfejsu) użytkownika.
Sales price 39,90 zł
Sales price without tax 38,00 zł
Discount

Preloader
ISBN 83-86969-38-5, 232 strony, oprawa twarda, wymiary 160x230 mm.

W książce przedstawiono problemy i zadania powstające przy tworzeniu systemów informatycznych. Uczy ona analizy, projektowania i programowania obiektowego. Opisuje sposób zarządzania procesem informatycznym i zasady tworzenia łącza programowego (interfejsu) użytkownika. Jest ilustrowana licznymi przykładami.

Spis treści:

Wstęp

O czym jest ta książka

Teoria i praktyka

Sześć powodów, dla których warto przeczytać tę książkę

Zdrowy rozsądek

Adresat książki jej mapa

Mapa dla programisty

Mapa dla projektanta

Mapa dla menedżera

Mapa dla studenta

Język i konwencje tej książki

Stylistyka

Terminy angielskie

Konwencje

Podziękowania

Inne podziękowania

Rozdział 1. Podstawy
1.1. Wprowadzenie
1.2. Obiekty
1..1. Obiekty wokół nas
1.2.2. Widzenie obiektowe kontra proceduralne
1.3. Klasy
1.3.1. Identyfikacja klas
1.3.2. Dziedziczenie
1.3.3. Dziedziczenie wielokrotne i jego konsekwencje
1.4. Zależności
1.4.1. Powiązanie
1.4.2. Złożenie
1.4.3. Cechy zależności
1.4.4. Szczególne rodzaje zależności
1.5. Operacje
1.5.1. Metody a funkcje
1.5.2. Konstruktor i destruktor
1.5.3. Metody klas
1.5.4. Hermetyzacja operacji
1.6. Klucz do obiektowości - polimorfizm
1.6.1. Polimorfizm w epoce kamienia łupanego
1.6.2. Polimorfizm tu i teraz
1.6.3. Polimorfizm i abstrakcja
1.6.4. Co jest, a co nie jest polimorfizmem 1.7. Atrybuty
1.7.1. Atrybuty kontra zależności
1.7.2. Hermetyzacja, odpowiedzialność i zaproszenie do kłopotów
1.8. Komponenty
1.8.1. Dlaczego kochamy komponenty
1.8.2. Długie życie komponentów
1.9. Literatura
1.10 Podsumowanie

Rozdział 2. Analiza i projekt
2.1. Opis układu
2.2. Analiza wymagań
2.2.1. Użytkownik – pan władca procesu tworzenia systemu
2.3. Analiza technologiczna
2.4. Dekompozycja problemu
2.4.1. Klasa – całość pojęciowa
2.4.2. Klasa – wydzielona odpowiedzialność
2.4.3. Klasa – użyteczna abstrakcja
2.4,4. Metoda kart CRC
2.4.5. Komponent – grupa klas
2.5. Zależności
2.5.1. Dziedziczenie
2.5.2. Ponowne użycie przez dziedziczenie
2.5.3. Współpraca
2.6. Scenariusze wykorzystania
2.6.1. Diagramy interakcji
2.6.2. Inicjatywa i odpowiedzialność
2.6.3. Szczegóły
2.6.4. Myśleć o wszystkim
2.7. Biblioteki
2.3. Między analizą a projektowaniem
2.9. Projektowanie interfejsu klasy
2,9.1. Interfejs – pierwsza i często ostatnia wiedza o klasie
2.9.2. Metody abstrakcyjne
2.9.3. Nazwy metod
2.9.4. Lista argumentów
2.9.5. Wartości
2.9.6. Błędy i wyjątki
2.9.7. Interfejs konstrukcji
2.10. Wzorce projektowania
2.11. O tym, co w środku
2.11.1. Owoce projektowania
2.12. Prototypowanie
2.12.1. Zalety płynące z prototypowania
2.12.2. Techniki prototypowania
2.12.3. Co zrobić z prototypem?
2.13. Obiekty w bazie danych
2.13.1. Model obiektowo-relacyjny
2.13.2. Bazy obiektowe
2.13.3. Przegląd produktów
2.14. Narzędzia analityka i projektanta
2.14.1. O zdrowym rozsądku
2.14.2. Mistrz i uczniowie
2.14.3. Narzędzia CASE
2.14.4. Technologie komponentów
2.15. Da capo
2.16. Notacja
2.17. Literatura
2.18. Podsumowanie

Rozdział 3. Implementacja
3.1. Wprowadzenie
3.1.1. C++ jako język ilustracji
3.2. “Żeby język giętki mógł powiedzieć, co pomyśli głowa”
3.2.1. Wybór języka programowania
3.2.2. C++
3.2.3. Visual Basic
3.2.4. Pascal
3.2.5. Java
3.2.6. Smalltalk
3.3. Programowanie klas
3.3.1. Granice projektu, początek programowania
3.3.2. Powiązania między obiektami
3.3.3. Konstrukcja i destrukcja
3.14. Zabawa w chowanego, czyli o hermetyzacji
3.3.5. Kompletność i elegancja
3.4. Programowanie metod
3.4.1. Implementacja scenariuszy
3.4.2. Jeżeli scenariusze się nie zgadzają
3.4.3. Kontrakt w obrębie metody
3.4.4. Krótki kurs samoobrony
3.5. O wyjątkach i innych demonach
3.5.1. Języki programowania i ich mechanizmy
3.5.2. Wyjątki a wartości metody
3.5.3. Wyjątki – pełnoprawne obiekty
3.6. Standardy, konwencje i przesądy
3.6.1. Konwencje nazewnictwa
3.6.2. Standardy stylistyczne
3.6.3. Słowo o wydajności
3.7. Testowanie i weryfikacja
3.7.1. Testy użytkowe
3.7.2. Testy poprawności
3.7.3. Testy wytrzymałości
3.7.4. Testy skalowalności
3.7.5. Czy małpa jest najlepszym testerem?
3.8. Literatura
3.9. Podsumowanie

Rozdział 4. Interfejs użytkownika
4.1. Wprowadzenie
4.2. Interfejs użytkownika a sukces
4.2.1. Krótka historia sukcesu
4.2.2. Zorientowanie na zadanie, a nie operację
4.2.3. Krzywa nauki
4.2.4. Podstawowa funkcja
4.2.5. Najpierw obiekt, potem czynność
4.2.6. Paradygmat MVC
4.3. Co, gdzie i jak
4.3.1. Przyjazność
4.3.2. Rozkład graficzny
4.3.3. Proporcje
4.3.4. Liczba elementów
4.3.5. Kolory
4.3.6. Grafika
4.3.7. Ikony
4.3.8. Język
4.3.9. Błędy
4.3.10. Pomoc
4.3.11. Klawiatura
4.4. Ekonomia ergonomii
4.4.1. Każdy ruch kosztuje
4.4.2. Poczucie komfortu
4.5. HTML i Java
4.6. Literatura
4.7. Podsumowanie

Rozdział 5. Technika programowania
5.1. Wprowadzenie
5.2. “Strzeżonego Pan Bóg strzeże”
5.2.1. Dwie strony medalu
5.2.2. Algorytm alternatywny
5.2.3. Typy i ich zakresy
5.2.4. Typy zmiennoprzecinkowe
5.2.5. assert
5.2.6. “Darmowe” metody
5.2.7. Deklaracja i inicjalizacja
5.2.8. Pamięć
5.3. Szybkie decyzje
5.3.1. Wskaźnik czy referencja?
5.3.2. Inteligentne wskaźniki
5.3.3. Pętla pętli nierówna
5.3.4. Wyjście ze środka pętli
5.3.5. Głupi robi dwa razy
5.3.6. Jedna zmienna, jeden cel
5.3.7. Magia stałych
5.3.8. Przyspieszenie kompilacji
5.4. Do czego służy program
5.4.1. Czytanie programu
5.4.2. Super sprytny kod
5.4.3. Grupowanie linii
5.4.4. Komentarze
5.4.5. Wykonanie krokowe (single-stepping)
5.4.6. Zwięzły czy optymalny?
5.4.7. Linia kodu – linia informacji
5.4.8. Robić to, co się obiecuje
5.4.9. Pozorne oszczędności
5.4.10. Bez popisywania się
5.4.11. Kolejność operacji
5.5. Literatura
5.6. Podsumowania

Rozdział 6. Proces i produkt
6.1. Wprowadzenie
6.2. Co to jest produkt?
6.2.1. Program
6.2.2. Dokumentacja
6.2.3. Dystrybucja i instalacja
6.2.4. Szkolenia
6.2.5. Wsparcie
6.3. Typy systemów
6.3.1. Typ 1: “Byle jak, byle dużo i szybko”
6.3.2. Typ 2: “Taki sam, ale inny”
6.3.3. Typ 3: “Czegoś chcemy, ale nie wiemy czego”
6.3.4. Typ 4: “My wiemy najlepiej”
6.3.5. Wnioski
6.4. Magiczny trójkąt: funkcjonalność, czas, zasoby
6.4.1. Nic za darmo
6.4.2. Szacunek dla siebie
6.5. Kopanie studni w sto osób, czyli rzecz o zespole
6.5.1. Kompletowanie zespołu
6.5.2. Fachowcy i pasjonaci
6.5.3. Hackerzy, liderzy, gwiazdorzy i reszta informatycznego bestiariusza
6.5.4. Nowi członkowie zespołu
6.5.5. Konstruktywna, wzajemna weryfikacja
6.5.6. Informatycy w spódnicach
6.6. Słowa-wytrychy: narzędzia, technologie i metodyki
ó.6.l. ,,Głupiec z narzędziem wciąż głupcem będzie”
6.6.2. Na temat produktywności
6.6.3. Ogarniać ryzyko
6.7. Synchronizacja i stabilizacja
6.7.1. Produkt każdego dnia
6.7.2. Kamienie milowe
6.7.3. “Potrząsanie galaretą”
6.7.4. Pokazy, targi i próbne instalacje
6.8. Czas żniw
6.8.1. Ponowne użycie
6.8.2. Alchemia zespołu
6.9. Utrzymanie
6.9.1. Zmienność – istota systemu informatycznego
6.9.2. Rodzaje zmian wymagań
6.9.3. Jak przewidywać nieprzewidziane?
6.9.4. Krótka historia jednego błędu
6.10. Literatura
6.11. Podsumowanie
6.11.1. Proces i produkt po polsku

Rozdział 7. Studium przykładowe – Kino
7.1. Wprowadzenie
7.2. Opis wymagań
7.3. Analiza
7.3.1. Analiza technologiczna
7.3.2. Identyfikacja klas metodą kart CRC
7.3.3. Zależność między klasami
7.3.4. Procesy
7.3.5. Warunki brzegowe
7.4. Projekt
7.4.1. Klasy, Seanse i Bilety
7.4.9. Synonimy typów prostych
7.4.3. Singleton Kino
7.4.4. Projektowanie klas
7.5. Implementacja
7.5.1. Deklaracje typów pomocniczych
7.5.2. Scenariusz zakupu biletu
7.5.3. Scenariusz dodawania nowego seansu
7.6. Zmiana wymagań
7.7. A jak to jest naprawdę?
7.7.1. Repozytorium obiektów
7.7.2. Kontakt z interfejsem użytkownika
7.7.3. Proces
7.8. Podsumowanie
Bibliografia
Słowniczek
Skorowidz