czytanie kodu. punkt widzenia twórców oprogramowania open source helion, moje ebooki
[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
SPIS TRECI
Czytanie kodu. Punkt widzenia
twórców oprogramowania
open source
KATALOG KSI¥¯EK
KATALOG ONLINE
Autor: Diomidis Spinellis
T³umaczenie: Bart³omiej Garbacz
ISBN: 83-7361-555-5
Tytu³ orygina³
Format: B5, stron: 448
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Ksi¹¿ka „Czytanie kodu. Punkt widzenia twórców oprogramowania” open source to
pierwszy na rynku podrêcznik powiêcony czytaniu kodu ród³owego jako osobnej
dziedzinie wiedzy, której znajomoæ jest przydatna ka¿demu programicie.
Ponad 600 przyk³adów, w których wykorzystywane s¹ kody oprogramowania open
source, przedstawia sposoby identyfikowania dobrego i z³ego kodu, czytania go,
przeszukiwania pod k¹tem konkretnych funkcji oraz wykorzystywania umiejêtnoci
czytania kodu do poprawy jakoci kodów ród³owych pisanych samodzielnie.
• Podstawowe konstrukcje steruj¹ce dzia³aniem programu
• Proste i z³o¿one typy danych
• Struktury i unie
• Dynamiczne zarz¹dzanie pamiêci¹
• Metody analizy projektów informatycznych
• Konwencje pisania i formatowania kodu ród³owego
• Tworzenie i czytanie dokumentacji
• Architektura systemów
Poznaj umiejêtnoæ czytania kodu ród³owego i popraw samodzielnie pisany kod
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWOCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treści
Przedmowa.....................................................................................7
Wstęp..........................................................................................11
Rozdział 1. Wprowadzenie ..............................................................................15
1.1. Motywy i metody czytania kodu......................................................................... 16
1.1.1. Kod jako literatura ................................................................................... 16
1.1.2. Kod jako model ....................................................................................... 19
1.1.3. Utrzymanie kodu ..................................................................................... 20
1.1.4. Rozwój.................................................................................................... 21
1.1.5. Ponowne wykorzystanie........................................................................... 22
1.1.6. Inspekcje ................................................................................................. 23
1.2. Jak czytać tę książkę? ........................................................................................ 24
1.2.1. Konwencje typograficzne......................................................................... 24
1.2.2. Diagramy ................................................................................................ 25
1.2.3. Ćwiczenia................................................................................................ 27
1.2.4. Materiał dodatkowy ................................................................................. 27
1.2.5. Narzędzia ................................................................................................ 28
1.2.6. Zarys treści.............................................................................................. 28
1.2.7. Debata na temat najlepszego języka.......................................................... 29
Dalsza lektura .......................................................................................................... 30
Rozdział 2. Podstawowe konstrukcje programistyczne ......................................33
2.1. Pełny program ................................................................................................... 33
2.2. Funkcje i zmienne globalne................................................................................ 39
2.3. Pętle while, instrukcje warunkowe i bloki........................................................... 42
2.4. Instrukcja switch................................................................................................ 45
2.5. Pętle for ............................................................................................................ 47
2.6. Instrukcje break i continue ................................................................................. 50
2.7. Wyrażenia znakowe i logiczne ........................................................................... 52
2.8. Instrukcja goto................................................................................................... 55
2.9. Refaktoryzacja w skrócie ................................................................................... 57
2.10. Pętle do i wyrażenia całkowite ........................................................................... 63
2.11. Podsumowanie wiadomości o strukturach sterujących......................................... 65
Dalsza lektura .......................................................................................................... 71
Rozdział 3. Zaawansowane typy danych języka C .............................................73
3.1. Wskaźniki ......................................................................................................... 73
3.1.1. Powiązane struktury danych ..................................................................... 74
3.1.2. Dynamiczne przydzielanie struktur danych ............................................... 74
4
Czytanie kodu. Punkt widzenia twórców oprogramowania open-source
3.1.3. Wywołania przez referencję ..................................................................... 75
3.1.4. Uzyskiwanie dostępu do elementów danych ............................................. 76
3.1.5. Tablice jako argumenty i wyniki .............................................................. 77
3.1.6. Wskaźniki na funkcje............................................................................... 78
3.1.7. Wskaźniki jako aliasy .............................................................................. 81
3.1.8. Wskaźniki a ciągi znaków........................................................................ 82
3.1.9. Bezpośredni dostęp do pamięci ................................................................ 84
3.2. Struktury ........................................................................................................... 85
3.2.1. Grupowanie elementów danych................................................................ 85
3.2.2. Zwracanie wielu elementów danych z funkcji ........................................... 85
3.2.3. Odwzorowanie organizacji danych ........................................................... 86
3.2.4. Programowanie obiektowe ....................................................................... 87
3.3. Unie .................................................................................................................. 89
3.3.1. Wydajne wykorzystanie pamięci .............................................................. 89
3.3.2. Implementacja polimorfizmu.................................................................... 90
3.3.3. Uzyskiwanie dostępu do różnych reprezentacji wewnętrznych .................. 91
3.4. Dynamiczne przydzielanie pamięci .................................................................... 92
3.4.1. Zarządzanie wolną pamięcią .................................................................... 95
3.4.2. Struktury z dynamicznie przydzielanymi tablicami ................................... 97
3.5. Deklaracje typedef............................................................................................. 98
Dalsza lektura ........................................................................................................ 100
Rozdział 4. Struktury danych języka C ...........................................................101
4.1. Wektory .......................................................................................................... 102
4.2. Macierze i tabele ............................................................................................. 106
4.3. Stosy ............................................................................................................... 110
4.4. Kolejki ............................................................................................................ 112
4.5. Mapy............................................................................................................... 114
4.5.1. Tablice mieszające................................................................................. 117
4.6. Zbiory ............................................................................................................. 119
4.7. Listy................................................................................................................ 120
4.8. Drzewa............................................................................................................ 127
4.9. Grafy............................................................................................................... 131
4.9.1. Przechowywanie wierzchołków.............................................................. 132
4.9.2. Reprezentacje krawędzi ......................................................................... 133
4.9.3. Przechowywanie krawędzi ..................................................................... 136
4.9.4. Właściwości grafu ................................................................................. 137
4.9.5. Struktury ukryte..................................................................................... 138
4.9.6. Inne reprezentacje.................................................................................. 138
Dalsza lektura ........................................................................................................ 139
Rozdział 5. Zaawansowane techniki sterowania przebiegiem programów ..........141
5.1. Rekurencja ...................................................................................................... 141
5.2. Wyjątki ........................................................................................................... 147
5.3. Równoległość.................................................................................................. 151
5.3.1. Równoległość sprzętowa i programowa .................................................. 151
5.3.2. Modele sterowania................................................................................. 153
5.3.3. Implementacja wątków .......................................................................... 158
5.4. Sygnały ........................................................................................................... 161
5.5. Skoki nielokalne.............................................................................................. 165
5.6. Podstawienie makr........................................................................................... 167
Dalsza lektura ........................................................................................................ 171
Spis treści
5
Rozdział 6. Metody analizy dużych projektów .................................................173
6.1. Techniki projektowe i implementacyjne ........................................................... 173
6.2. Organizacja projektu........................................................................................ 175
6.3. Proces budowy i pliki Makefile ........................................................................ 183
6.4. Konfiguracja.................................................................................................... 190
6.5. Kontrola wersji................................................................................................ 194
6.6. Narzędzia związane z projektem ...................................................................... 201
6.7. Testowanie ...................................................................................................... 205
Dalsza lektura ........................................................................................................ 212
Rozdział 7. Standardy i konwencje pisania kodu .............................................213
7.1. Nazwy plików i ich organizacja wewnętrzna..................................................... 214
7.2. Wcięcia ........................................................................................................... 216
7.3. Formatowanie.................................................................................................. 218
7.4. Konwencje nazewnictwa.................................................................................. 221
7.5. Praktyki programistyczne................................................................................. 224
7.6. Standardy związane z procesem rozwojowym................................................... 226
Dalsza lektura ........................................................................................................ 227
Rozdział 8. Dokumentacja ............................................................................229
8.1. Rodzaje dokumentacji...................................................................................... 229
8.2. Czytanie dokumentacji..................................................................................... 230
8.3. Problemy dotyczące dokumentacji ................................................................... 241
8.4. Dodatkowe źródła dokumentacji ...................................................................... 242
8.5. Popularne formaty dokumentacji w środowisku open-source............................. 246
Dalsza lektura ........................................................................................................ 251
Rozdział 9. Architektura ...............................................................................253
9.1. Struktury systemów ......................................................................................... 253
9.1.1. Podejście scentralizowanego repozytorium i rozproszone........................ 254
9.1.2. Architektura przepływu danych .............................................................. 259
9.1.3. Struktury obiektowe............................................................................... 261
9.1.4. Architektury warstwowe ........................................................................ 264
9.1.5. Hierarchie.............................................................................................. 266
9.1.6. Przecinanie............................................................................................ 267
9.2. Modele sterowania........................................................................................... 269
9.2.1. Systemy sterowane zdarzeniami ............................................................. 269
9.2.2. Menedżer systemowy............................................................................. 273
9.2.3. Przejścia stanów .................................................................................... 274
9.3. Pakietowanie elementów.................................................................................. 277
9.3.1. Moduły.................................................................................................. 277
9.3.2. Przestrzenie nazw .................................................................................. 279
9.3.3. Obiekty ................................................................................................. 283
9.3.4. Implementacje ogólne............................................................................ 295
9.3.5. Abstrakcyjne typy danych ...................................................................... 298
9.3.6. Biblioteki .............................................................................................. 299
9.3.7. Procesy i filtry ....................................................................................... 302
9.3.8. Komponenty.......................................................................................... 304
9.3.9. Repozytoria danych ............................................................................... 306
9.4. Wielokrotne użycie architektury....................................................................... 308
9.4.1. Schematy strukturalne............................................................................ 308
9.4.2. Generatory kodu .................................................................................... 309
9.4.3. Wzorce projektowe................................................................................ 310
9.4.4. Architektury dziedzinowe ...................................................................... 312
Dalsza lektura ........................................................................................................ 316
6
Czytanie kodu. Punkt widzenia twórców oprogramowania open-source
Rozdział 10. Narzędzia pomocne w czytaniu kodu .............................................319
10.1. Wyrażenia regularne ...................................................................................... 320
10.2. Edytor jako przeglądarka kodu ....................................................................... 323
10.3. Przeszukiwanie kodu za pomocą narzędzia grep ............................................. 326
10.4. Znajdowanie różnic między plikami ............................................................... 333
10.5. Własne narzędzia........................................................................................... 335
10.6. Kompilator jako narzędzie pomocne w czytaniu kodu ..................................... 338
10.7. Przeglądarki i upiększacze kodu ..................................................................... 342
10.8. Narzędzia używane w czasie uruchomienia..................................................... 347
10.9. Narzędzia nieprogramowe.............................................................................. 351
Dostępność narzędzi oraz dalsza lektura.................................................................. 353
Rozdział 11. Pełny przykład ............................................................................355
11.1. Przegląd ........................................................................................................ 355
11.2. Plan działania ................................................................................................ 356
11.3. Wielokrotne użycie kodu................................................................................ 358
11.4. Testowanie i uruchamianie............................................................................. 363
11.5. Dokumentacja................................................................................................ 368
11.6. Uwagi ........................................................................................................... 369
Dodatek A Struktura dołączonego kodu.........................................................371
Dodatek B Podziękowania dla autorów kodu źródłowego.................................375
Dodatek C Pliki źródłowe .............................................................................377
Dodatek D Licencje kodu źródłowego ............................................................385
D.1. ACE ............................................................................................................... 385
D.2. Apache ........................................................................................................... 386
D.3. ArgoUML ...................................................................................................... 387
D.4. DemoGL ........................................................................................................ 388
D.5. hsqldb ............................................................................................................ 388
D.6. NetBSD.......................................................................................................... 389
D.7. OpenCL.......................................................................................................... 390
D.8. Perl ................................................................................................................ 390
D.9. qtchat ............................................................................................................. 393
D.10. socket............................................................................................................. 393
D.11. vcf.................................................................................................................. 393
D.12. X Window System.......................................................................................... 394
Dodatek E Porady dotyczące czytania kodu...................................................395
Bibliografia.................................................................................413
Skorowidz...................................................................................427
[ Pobierz całość w formacie PDF ]