• Jaki edytor wybrać?
• Jak działają systemy kontroli wersji?
• Jak zapewnić wysoką wydajność oraz bezbłędne działanie tworzonych rozwiązań?

Programista, jak każdy fachowiec, posiada perfekcyjnie dobrany zestaw narzędzi, pozwalający mu na szybkie, wygodne, elastyczne i - co najważniejsze - optymalne rozwiązywanie postawionych problemów. Wybranie odpowiednich narzędzi i skomponowanie ich zbioru zabiera często wiele dni, miesięcy, a nawet i lat. A przecież my, programiści, nie mamy aż tyle czasu! Koniecznie trzeba znaleźć jakiś szybszy sposób!

Najlepszą odpowiedzią na ten problem jest właśnie niniejsza książka. Dzięki niej opanujesz sposoby pobierania i instalacji różnych narzędzi, a nowo nabyta wiedza na temat sposobów zarządzania pakietami w różnych dystrybucjach na pewno nie pójdzie na marne. W kolejnych rozdziałach poznasz przebieg procesu kompilacji oraz dowiesz się, jak interpretować poszczególne błędy i ostrzeżenia. John Fusco omawia tu także edytory Vim oraz Emacs - ale nie wskazuje, który z nich jest lepszy! Dzięki książce "Linux. Niezbędnik projektanta" wykorzystanie systemów kontroli wersji nie będzie stanowiło dla Ciebie najmniejszego problemu. Na kolejnych stronach szczegółowo omawiane są zasady funkcjonowania jądra systemu oraz sposób działania procesów i komunikacji między nimi. Lektura kolejnych rozdziałów dostarczy Ci niezbędnych informacji na temat zapewniania wysokiej wydajności tworzonych rozwiązań oraz metod diagnozowania problemów z oprogramowaniem.

• Zdobywanie i instalacja oprogramowania open source
• Proces kompilacji kodu źródłowego
• Zarządzanie pakietami w różnych dystrybucjach
• Interpretacja komunikatów o błędach i ostrzeżeń
• Edytory plików tekstowych
• Wykorzystanie systemów kontroli wersji
• Funkcjonowanie jądra systemu operacyjnego Linux
• Wykorzystanie procesów
• Komunikacja między procesami
• Diagnozowanie problemów z komunikacją pomiędzy procesami
• Zwiększanie wydajności tworzonych rozwiązań
• Wykrywanie problemów w napisanym oprogramowaniu

Osoby które kupowały "Linux. Niezbędnik programisty", wybierały także:

• Administracja systemem Linux. Kurs video. Przewodnik dla początkujących 59,00 zł, (17,70 zł -70%)
• Gray Hat C#. Język C# w kontroli i łamaniu zabezpieczeń 57,74 zł, (17,90 zł -69%)
• Cybersecurity dla ka 149,00 zł, (74,50 zł -50%)
• Python dla administrator 178,98 zł, (89,49 zł -50%)
• Linux. Kurs video. SSH, terminal, skrypty i automatyzacja 119,00 zł, (59,50 zł -50%)

Spis treści

Linux. Niezbędnik programisty -- spis treści

Słowo wstępne (17)

Przedmowa (19)

Podziękowania (25)

O autorze (27)

Rozdział 1. Pobieranie i instalacja narzędzi oferowanych w trybie open source (29)

• 1.1. Wprowadzenie (29)
• 1.2. Czym jest tryb open source? (30)
• 1.3. Co idea otwartego dostępu do kodu źródłowego oznacza dla nas? (30)
  • 1.3.1. Odnajdywanie właściwych narzędzi (31)
  • 1.3.2. Formaty dystrybucji oprogramowania (32)
• 1.4. Wprowadzenie do tematyki plików archiwalnych (33)
  • 1.4.1. Identyfikacja plików archiwalnych (35)
  • 1.4.2. Przeglądanie zawartości plików archiwalnych (36)
  • 1.4.3. Rozpakowywanie plików z pliku archiwalnego (40)
• 1.5. Poznajmy wykorzystywany menedżer pakietów (42)
  • 1.5.1. Wybór pomiędzy kodem źródłowym a wersją binarną (43)
  • 1.5.2. Praca z pakietami (46)
• 1.6. Kilka słów o bezpieczeństwie w kontekście pakietów (46)
  • 1.6.1. Potrzeba uwierzytelniania (48)
  • 1.6.2. Podstawowe uwierzytelnianie pakietów (49)
  • 1.6.3. Uwierzytelnianie pakietów z podpisami cyfrowymi (51)
  • 1.6.4. Podpisy narzędzia GPG, stosowane dla pakietów RPM (52)
  • 1.6.5. Kiedy uwierzytelnienie pakietu jest niemożliwe (56)
• 1.7. Analiza zawartości pakietu (57)
  • 1.7.1. Jak analizować pobrane pakiety (59)
  • 1.7.2. Szczegółowa analiza pakietów RPM (61)
  • 1.7.3. Szczegółowa analiza pakietów Debiana (62)
• 1.8. Aktualizowanie pakietów (64)
  • 1.8.1. APT 3 Advanced Package Tool (66)
  • 1.8.2. YUM 3 Yellowdog Updater Modified (67)
  • 1.8.3. Synaptic 3 nakładka narzędzia APT z graficznym interfejsem użytkownika (67)
  • 1.8.4. up2date 3 narzędzie aktualizujące pakiety dystrybucji Red Hat (69)
• 1.9. Podsumowanie (71)
  • 1.9.1. Narzędzia użyte w tym rozdziale (71)
  • 1.9.2. Materiały dostępne w internecie (72)

Rozdział 2. Kompilacja kodu źródłowego (73)

• 2.1. Wprowadzenie (73)
• 2.2. Narzędzia kompilujące (74)
  • 2.2.1. Rys historyczny (74)
  • 2.2.2. Zrozumieć program make (77)
  • 2.2.3. Jak przebiega proces łączenia programów (103)
  • 2.2.4. Zrozumieć biblioteki (104)
• 2.3. Proces kompilacji (109)
  • 2.3.1. Narzędzia kompilacji GNU (110)
  • 2.3.2. Etap konfiguracji (skrypt configure) (111)
  • 2.3.3. Etap kompilacji 3 narzędzie make (113)
  • 2.3.4. Etap instalacji 3 polecenie make install (114)
• 2.4. Zrozumieć błędy i ostrzeżenia (115)
  • 2.4.1. Typowe błędy w plikach Makefile (115)
  • 2.4.2. Błędy na etapie konfiguracji (119)
  • 2.4.3. Błędy na etapie kompilacji (120)
  • 2.4.4. Zrozumieć błędy kompilatora (124)
  • 2.4.5. Zrozumieć ostrzeżenia kompilatora (126)
  • 2.4.6. Zrozumieć błędy programu łączącego (138)
• 2.5. Podsumowanie (140)
  • 2.5.1. Narzędzia użyte w tym rozdziale (140)
  • 2.5.2. Materiały dostępne w internecie (141)

Rozdział 3. Szukanie pomocy (143)

• 3.1. Wprowadzenie (143)
• 3.2. Narzędzia pomocy elektronicznej (144)
  • 3.2.1. Strona man (144)
  • 3.2.2. Organizacja stron man (145)
  • 3.2.3. Przeszukiwanie stron man - narzędzie apropos (149)
  • 3.2.4. Poszukiwanie właściwych stron man - polecenie whatis (151)
  • 3.2.5. Czego należy szukać na stronach man (152)
  • 3.2.6. Kilka szczególnie przydatnych stron man (153)
  • 3.2.7. Narzędzie info projektu GNU (155)
  • 3.2.8. Przeglądanie stron info (156)
  • 3.2.9. Przeszukiwanie stron info (159)
  • 3.2.10. Zalecane strony info (160)
  • 3.2.11. Narzędzia pomocy uruchamiane na pulpicie (160)
• 3.3. Pozostałe źródła pomocy (162)
  • 3.3.1. Katalog /usr/share/doc (162)
  • 3.3.2. Odwołania do innych stron oraz mechanizmy indeksowania (163)
  • 3.3.3. Zapytania kierowane do pakietów (164)
• 3.4. Formaty dokumentacji (166)
  • 3.4.1. Formaty TeX, LaTeX i DVI (166)
  • 3.4.2. Format Texinfo (167)
  • 3.4.3. Format DocBook (168)
  • 3.4.4. Język HTML (169)
  • 3.4.5. Język PostScript (171)
  • 3.4.6. Format PDF (173)
  • 3.4.7. Język troff (174)
• 3.5. Źródła informacji w internecie (174)
  • 3.5.1. Witryna http://www.gnu.org/ (175)
  • 3.5.2. Witryna http://SourceForge.net/ (175)
  • 3.5.3. Witryna projektu The Linux Documentation Project (176)
  • 3.5.4. Grupy dyskusyjne Usenet (177)
  • 3.5.5. Listy dyskusyjne (177)
  • 3.5.6. Pozostałe fora (178)
• 3.6. Odnajdywanie informacji o jądrze systemu Linux (178)
  • 3.6.1. Kompilacja jądra (178)
  • 3.6.2. Moduły jądra (180)
  • 3.6.3. Pozostałe źródła dokumentacji (182)
• 3.7. Podsumowanie (182)
  • 3.7.1. Narzędzia użyte w tym rozdziale (182)
  • 3.7.2. Materiały dostępne w internecie (183)

Rozdział 4. Edycja i konserwacja plików źródłowych (185)

• 4.1. Wprowadzenie (185)
• 4.2. Edytor tekstu (186)
  • 4.2.1. Edytor domyślny (188)
  • 4.2.2. Jakich funkcji należy szukać w edytorze tekstu (188)
  • 4.2.3. Wielka dwójka - vi oraz Emacs (190)
  • 4.2.4. Vim - udoskonalony edytor vi (191)
  • 4.2.5. Edytor Emacs (215)
  • 4.2.6. Atak klonów (227)
  • 4.2.7. Podstawowe informacje o kilku edytorach tekstu z graficznym interfejsem użytkownika (230)
  • 4.2.8. Wymagania pamięciowe (235)
  • 4.2.9. Podsumowanie wiadomości o edytorach (237)
• 4.3. Kontrola wersji (238)
  • 4.3.1. Podstawy kontroli wersji (238)
  • 4.3.2. Terminologia obowiązująca w świecie kontroli wersji (240)
  • 4.3.3. Narzędzia pomocnicze (243)
  • 4.3.4. Podstawy poleceń diff i patch (243)
  • 4.3.5. Przeglądanie i scalanie zmian (247)
• 4.4. Upiększacze i przeglądarki kodu źródłowego (254)
  • 4.4.1. Upiększacze wcięć w kodzie źródłowym (255)
  • 4.4.2. Artystyczny styl narzędzia astyle (258)
  • 4.4.3. Analiza kodu za pomocą narzędzia cflow (259)
  • 4.4.4. Analiza kodu za pomocą narzędzia ctags (262)
  • 4.4.5. Przeglądanie kodu za pomocą narzędzia cscope (262)
  • 4.4.6. Przeglądanie i dokumentowanie kodu za pomocą narzędzia Doxygen (264)
  • 4.4.7. Analiza kodu źródłowego z wykorzystaniem kompilatora (266)
• 4.5. Podsumowanie (268)
  • 4.5.1. Narzędzia użyte w tym rozdziale (269)
  • 4.5.2. Bibliografia (270)
  • 4.5.3. Materiały dostępne w internecie (270)

Rozdział 5. Co każdy programista powinien wiedzieć o jądrze systemu (273)

• 5.1. Wprowadzenie (273)
• 5.2. Tryb użytkownika a tryb jądra (274)
  • 5.2.1. Wywołania systemowe (276)
  • 5.2.2. Przenoszenie danych pomiędzy przestrzenią użytkownika a przestrzenią jądra (278)
• 5.3. Mechanizm szeregowania procesów (279)
  • 5.3.1. Reguły szeregowania procesów (279)
  • 5.3.2. Blokowanie, wywłaszczanie i rezygnacje (282)
  • 5.3.3. Priorytety szeregowania i kwestia sprawiedliwości (283)
  • 5.3.4. Priorytety i wartość nice (287)
  • 5.3.5. Priorytety czasu rzeczywistego (289)
  • 5.3.6. Tworzenie procesów czasu rzeczywistego (292)
  • 5.3.7. Stany procesów (294)
  • 5.3.8. Jak jest mierzony czas pracy procesów (301)
• 5.4. Zrozumieć urządzenia i sterowniki urządzeń (313)
  • 5.4.1. Rodzaje sterowników urządzeń (314)
  • 5.4.2. Słowo o modułach jądra (316)
  • 5.4.3. Węzły urządzeń (317)
  • 5.4.4. Urządzenia i operacje wejścia-wyjścia (330)
• 5.5. Mechanizm szeregowania operacji wejścia-wyjścia (340)
  • 5.5.1. Winda Linusa (znana też jako noop) (342)
  • 5.5.2. Mechanizm szeregowania operacji wejścia-wyjścia z terminem granicznym (343)
  • 5.5.3. Przewidujący mechanizm szeregowania operacji wejścia-wyjścia (344)
  • 5.5.4. Mechanizm szeregowania operacji wejścia-wyjścia z pełnym kolejkowaniem (344)
  • 5.5.5. Wybór mechanizmu szeregowania operacji wejścia-wyjścia (344)
• 5.6. Zarządzanie pamięcią w przestrzeni użytkownika (345)
  • 5.6.1. Omówienie pamięci wirtualnej (346)
  • 5.6.2. Wyczerpanie dostępnej pamięci (363)
• 5.7. Podsumowanie (378)
  • 5.7.1. Narzędzia użyte w tym rozdziale (378)
  • 5.7.2. Interfejsy API omówione w tym rozdziale (379)
  • 5.7.3. Materiały dostępne w internecie (379)
  • 5.7.4. Bibliografia (379)

Rozdział 6. Zrozumieć procesy (381)

• 6.1. Wprowadzenie (381)
• 6.2. Skąd się biorą procesy (381)
  • 6.2.1. Wywołania systemowe fork i vfork (382)
  • 6.2.2. Kopiowanie przy zapisie (383)
  • 6.2.3. Wywołanie systemowe clone (384)
• 6.3. Funkcje z rodziny exec (384)
  • 6.3.1. Skrypty wykonywalne (385)
  • 6.3.2. Wykonywalne pliki obiektów (387)
  • 6.3.3. Rozmaite binaria (389)
• 6.4. Synchronizacja procesów za pomocą funkcji wait (392)
• 6.5. Wymagania pamięciowe procesu (394)
  • 6.5.1. Deskryptory plików (397)
  • 6.5.2. Stos (404)
  • 6.5.3. Pamięć rezydentna i pamięć zablokowana (405)
• 6.6. Ustawianie ograniczeń dla procesów (406)
• 6.7. Procesy i system plików procfs (410)
• 6.8. Narzędzia do zarządzania procesami (413)
  • 6.8.1. Wyświetlanie informacji o procesach za pomocą polecenia ps (413)
  • 6.8.2. Zaawansowane informacje o procesach, uzyskiwane z wykorzystaniem formatów (416)
  • 6.8.3. Odnajdywanie procesów według nazw za pomocą poleceń ps i pgrep (419)
  • 6.8.4. Śledzenie wymagań pamięciowych procesu za pomocą polecenia pmap (420)
  • 6.8.5. Wysyłanie sygnałów do procesów identyfikowanych przez nazwy (422)
• 6.9. Podsumowanie (423)
  • 6.9.1. Wywołania systemowe i interfejsy API użyte w tym rozdziale (423)
  • 6.9.2. Narzędzia użyte w tym rozdziale (424)
  • 6.9.3. Materiały dostępne w internecie (424)

Rozdział 7. Komunikacja pomiędzy procesami (425)

• 7.1. Wprowadzenie (425)
• 7.2. Technika IPC z wykorzystaniem zwykłych plików (426)
  • 7.2.1. Blokowanie plików (431)
  • 7.2.2. Wady implementacji techniki IPC z wykorzystaniem plików (432)
• 7.3. Pamięć współdzielona (432)
  • 7.3.1. Zarządzanie pamięcią współdzieloną za pośrednictwem interfejsu POSIX API (433)
  • 7.3.2. Zarządzanie pamięcią współdzieloną za pośrednictwem interfejsu System V API (437)
• 7.4. Sygnały (440)
  • 7.4.1. Wysyłanie sygnałów do procesu (441)
  • 7.4.2. Obsługa sygnałów (442)
  • 7.4.3. Maska sygnałów i obsługa sygnałów (444)
  • 7.4.4. Sygnały czasu rzeczywistego (447)
  • 7.4.5. Zaawansowane operacje na sygnałach z wykorzystaniem funkcji sigqueue i sigaction (450)
• 7.5. Potoki (453)
• 7.6. Gniazda (454)
  • 7.6.1. Tworzenie gniazd (455)
  • 7.6.2. Przykład gniazda lokalnego, utworzonego za pomocą funkcji socketpair (458)
  • 7.6.3. Przykład aplikacji klient-serwer, zbudowanej z wykorzystaniem gniazd lokalnych (459)
  • 7.6.4. Przykład aplikacji klient-serwer, zbudowanej z wykorzystaniem gniazd sieciowych (465)
• 7.7. Kolejki komunikatów (466)
  • 7.7.1. Kolejka komunikatów standardu System V (467)
  • 7.7.2. Kolejka komunikatów standardu POSIX (471)
  • 7.7.3. Różnice dzielące kolejki komunikatów standardów POSIX i System V (476)
• 7.8. Semafory (477)
  • 7.8.1. Interfejs API semaforów standardu POSIX (483)
  • 7.8.2. Interfejs API semaforów standardu System V (486)
• 7.9. Podsumowanie (488)
  • 7.9.1. Wywołania systemowe i interfejsy API użyte w tym rozdziale (489)
  • 7.9.2. Bibliografia (490)
  • 7.9.3. Materiały dostępne w internecie (490)

Rozdział 8. Diagnozowanie mechanizmów komunikacji międzyprocesowej za pomocą poleceń powłoki (491)

• 8.1. Wprowadzenie (491)
• 8.2. Narzędzia operujące na otwartych plikach (491)
  • 8.2.1. Polecenie lsof (492)
  • 8.2.2. Polecenie fuser (493)
  • 8.2.3. Polecenie ls (494)
  • 8.2.4. Polecenie file (495)
  • 8.2.5. Polecenie stat (495)
• 8.3. Zrzucanie danych z pliku (496)
  • 8.3.1. Polecenie strings (499)
  • 8.3.2. Polecenie xxd (500)
  • 8.3.3. Polecenie hexdump (501)
  • 8.3.4. Polecenie od (502)
• 8.4. Narzędzia powłoki do obsługi komunikacji międzyprocesowej standardu System V (504)
  • 8.4.1. Pamięć współdzielona standardu System V (504)
  • 8.4.2. Kolejki komunikatów standardu System V (507)
  • 8.4.3. Semafory standardu System V (509)
• 8.5. Narzędzia powłoki do obsługi komunikacji międzyprocesowej standardu POSIX (510)
  • 8.5.1. Pamięć współdzielona standardu POSIX (510)
  • 8.5.2. Kolejki komunikatów standardu POSIX (511)
  • 8.5.3. Semafory standardu POSIX (512)
• 8.6. Narzędzia pomocne w pracy z sygnałami (514)
• 8.7. Narzędzia pomocne w pracy z potokami i gniazdami (516)
  • 8.7.1. Potoki i struktury FIFO (517)
  • 8.7.2. Gniazda (518)
• 8.8. Identyfikacja plików i obiektów IPC na podstawie i-węzłów (521)
• 8.9. Podsumowanie (523)
  • 8.9.1. Narzędzia wykorzystane w tym rozdziale (523)
  • 8.9.2. Materiały dostępne w internecie (523)

Rozdział 9. Doskonalenie wydajności (525)

• 9.1. Wprowadzenie (525)
• 9.2. Wydajność systemu (525)
  • 9.2.1. Problemy związane z pamięcią (526)
  • 9.2.2. Wykorzystanie procesora i rywalizacja o dostęp do magistrali (537)
  • 9.2.3. Urządzenia i przerwania (541)
  • 9.2.4. Narzędzia umożliwiające identyfikację problemów w zakresie wydajności systemu (550)
• 9.3. Wydajność aplikacji (560)
  • 9.3.1. Pierwsze kroki - polecenie time (560)
  • 9.3.2. Zrozumieć architekturę procesora z wykorzystaniem narzędzia x86info (561)
  • 9.3.3. Stosowanie pakietu Valgrind do analizy efektywności rozkazów (565)
  • 9.3.4. Wprowadzenie do narzędzia ltrace (570)
  • 9.3.5. Stosowanie narzędzia strace do monitorowania wydajności programu (572)
  • 9.3.6. Tradycyjne programy do optymalizacji oprogramowania - gcov oraz gprof (574)
  • 9.3.7. Podstawowe informacje o narzędziu OProfile (583)
• 9.4. Wydajność w środowisku wieloprocesorowym (590)
  • 9.4.1. Rodzaje systemów SMP (591)
  • 9.4.2. Programowanie dla komputerów SMP (596)
• 9.5. Podsumowanie (600)
  • 9.5.1. Omówione w tym rozdziale problemy związane z wydajnością (601)
  • 9.5.2. Terminy wprowadzone w tym rozdziale (601)
  • 9.5.3. Narzędzia wykorzystane w tym rozdziale (601)
  • 9.5.4. Materiały dostępne w internecie (602)
  • 9.5.5. Bibliografia (602)

Rozdział 10. Diagnozowanie oprogramowania (603)

• 10.1. Wprowadzenie (603)
• 10.2. Najprostsze narzędzie diagnostyczne - funkcja printf (604)
  • 10.2.1. Problemy związane ze stosowaniem funkcji printf w roli narzędzia diagnostycznego (604)
  • 10.2.2. Efektywne korzystanie z funkcji printf (610)
  • 10.2.3. Kilka słów podsumowania metod diagnozowania oprogramowania z wykorzystaniem funkcji printf (620)
• 10.3. Jak opanować podstawy debugera GNU - gdb (622)
  • 10.3.1. Wykonywanie kodu pod kontrolą debugera gdb (623)
  • 10.3.2. Zatrzymywanie i wznawianie wykonywania kodu (624)
  • 10.3.3. Analiza i modyfikowanie danych (636)
  • 10.3.4. Dołączanie debugera gdb do pracującego procesu (649)
  • 10.3.5. Diagnozowanie plików rdzenia (649)
  • 10.3.6. Diagnozowanie programów wielowątkowych za pomocą debugera gdb (653)
  • 10.3.7. Diagnozowanie zoptymalizowanego kodu (655)
• 10.4. Diagnozowanie obiektów dzielonych (659)
  • 10.4.1. Kiedy i dlaczego stosujemy obiekty dzielone (659)
  • 10.4.2. Tworzenie obiektów dzielonych (660)
  • 10.4.3. Lokalizowanie obiektów dzielonych (661)
  • 10.4.4. Nadpisywanie domyślnych lokalizacji obiektów dzielonych (662)
  • 10.4.5. Problemy związane z bezpieczeństwem obiektów dzielonych (663)
  • 10.4.6. Narzędzia wykorzystywane w pracy z obiektami dzielonymi (663)
• 10.5. Poszukiwanie problemów związanych z pamięcią (667)
  • 10.5.1. Podwójne zwalnianie pamięci (668)
  • 10.5.2. Wycieki pamięci (668)
  • 10.5.3. Przepełnienia buforów (669)
  • 10.5.4. Narzędzia biblioteki standardowej glibc (671)
  • 10.5.5. Diagnozowanie problemów związanych z pamięcią za pomocą pakietu Valgrind (675)
  • 10.5.6. Identyfikacja przepełnień za pomocą debugera Electric Fence (682)
• 10.6. Techniki niekonwencjonalne (685)
  • 10.6.1. Tworzenie własnych czarnych skrzynek (685)
  • 10.6.2. Śledzenie wsteczne w czasie wykonywania (688)
  • 10.6.3. Wymuszanie zrzutów rdzenia (691)
  • 10.6.4. Stosowanie sygnałów (692)
  • 10.6.5. Diagnozowanie oprogramowania z wykorzystaniem systemu pakietu procfs (693)
• 10.7. Podsumowanie (696)
  • 10.7.1. Narzędzia wykorzystane w tym rozdziale (697)
  • 10.7.2. Materiały dostępne w internecie (697)
  • 10.7.3. Bibliografia (697)

Skorowidz (699)