Systemy kontroli wersji przechodzą ciągłą ewolucję. Jeszcze niedawno popularny był system CVS, który został wyparty przez SVN. Ostatnie lata to inwazja rozproszonych systemów kontroli wersji z Gitem na czele. Git pozwala każdemu programiście na posiadanie prywatnego repozytorium i korzystanie z jego dobrodziejstw bez wpływu na inne repozytoria. Jesteś ciekaw, jakie jeszcze zalety ma Git?

Jeżeli tak, trafiłeś na idealną książkę, dzięki której błyskawicznie wkroczysz w świat Gita. Na początek krok po kroku przejdziesz przez proces instalacji, a następnie dostosujesz środowisko do swoich potrzeb. W kolejnych rozdziałach poznasz dostępne polecenia oraz nauczysz się zarządzać plikami. Ponadto przekonasz się, jak łatwo można stworzyć odgałęzienia kodu oraz przeglądać różnice pomiędzy wersjami pliku. Git posiada zaawansowane narzędzia do łączenia kodu - będziesz mógł je dogłębnie poznać. Na koniec przeczytasz o zaawansowanych możliwościach systemu Git, takich jak współpraca z SVN. Ta książka jest doskonałym podręcznikiem dla każdego początkującego użytkownika systemu Git, zaawansowani również znajdą tu sporo przydatnych informacji. Wykorzystaj potencjał Gita!

Dzięki tej książce:

• odkryjesz rozproszone systemy kontroli wersji
• poznasz ich zalety
• zainstalujesz i skonfigurujesz system Git
• poznasz system kontroli wersji Git

Wykorzystaj potencjał systemu kontroli wersji Git!

Osoby które kupowały "Kontrola wersji z systemem Git. Narzędzia i techniki programistów. Wydanie II", wybierały także:

• DevOps w praktyce. Kurs video. Jenkins, Ansible, Terraform i Docker 190,00 zł, (39,90 zł -79%)
• Wyrażenia regularne od podstaw 39,67 zł, (11,90 zł -70%)
• Projektowanie systemów rozproszonych. Wzorce i paradygmaty dla skalowalnych, niezawodnych usług 39,67 zł, (11,90 zł -70%)
• Zrozum struktury danych. Algorytmy i praca na danych w Javie 39,67 zł, (11,90 zł -70%)
• Kosymulacja. Elastyczne projektowanie i symulacja wielodomenowa 38,39 zł, (11,90 zł -69%)

Spis treści

Kontrola wersji z systemem Git. Narzędzia i techniki programistów. Wydanie II eBook -- spis treści

Przedmowa (11)

1. Wprowadzenie (17)

• Podstawy (17)
• Narodziny Gita (18)
• Poprzednicy (20)
• Na osi czasu (21)
• Cóż to za nazwa? (22)

2. Instalowanie Gita (23)

• Zastosowanie binarnych dystrybucji Linuksa (23)
  
  • Dystrybucje Debian lub Ubuntu (23)
  • Inne dystrybucje binarne (24)
• Uzyskanie wydania źródłowego (25)
• Budowanie i instalowanie (26)
• Instalowanie Gita w systemie Windows (27)
  
  • Instalowanie pakietu Git w systemie Cygwin (28)
  • Instalowanie wolno stojącej wersji Gita (msysGit) (29)

3. Na dobry początek (31)

• Polecenie git (31)
• Szybkie wprowadzenie do użytkowania Gita (33)
  
  • Tworzenie archiwum początkowego (33)
  • Dodawanie pliku do Twojego archiwum (34)
  • Konfigurowanie autora zatwierdzenia (35)
  • Wykonanie kolejnego zatwierdzenia (36)
  • Przeglądanie Twoich zatwierdzeń (36)
  • Przeglądanie różnic w zatwierdzeniach (37)
  • Usuwanie i przemianowywanie plików w Twoim archiwum (38)
  • Tworzenie kopii Twojego archiwum (39)
• Pliki konfiguracyjne (39)
  
  • Konfigurowanie synonimu (41)
• Zasięganie języka (42)

4. Podstawowe koncepcje Gita (43)

• Pojęcia podstawowe (43)
• Archiwa (43)
  
  • Typy obiektów Gita (44)
  • Indeks (45)
  • Nazwy adresowane treścią (46)
  • Git nadzoruje treść (46)
  • Nazwy ścieżek a treść (47)
  • Pliki pakowane (48)
• Obrazy magazynu obiektów (49)
• Koncepcje Gita uwidocznione w działaniu (51)
  
  • Zawartość katalogu .git (51)
  • Obiekty, haszowania i bloby (52)
  • Pliki i drzewa (53)
  • Uwaga o zastosowaniu w Gicie algorytmu SHA1 (54)
  • Hierarchie drzewiaste (55)
  • Zatwierdzenia (56)
  • Metki (57)

5. Zarządzanie plikami a indeks (59)

• Wszystko kręci się wokół indeksu (59)
• Klasyfikacje plików w Gicie (60)
• Użycie polecenia git add (62)
• Kilka uwag o stosowaniu polecenia git commit (64)
  
  • Użycie polecenia git commit --all (64)
  • Zapisywanie komunikatów dziennika zatwierdzeń (65)
• Użycie polecenia git rm (65)
• Użycie polecenia git mv (67)
• Uwaga o śledzeniu przemianowań (68)
• Plik .gitignore (69)
• Szczegółowy przegląd modelu obiektowego i plików Gita (71)

6. Zatwierdzenia (77)

• Niepodzielne zbiory zmian (78)
• Identyfikowanie zatwierdzeń (79)
  
  • Bezwzględne nazwy zatwierdzeń (79)
  • Refy i symrefy (80)
  • Względne nazwy zatwierdzeń (81)
• Historia zatwierdzeń (83)
  
  • Przeglądanie starych zatwierdzeń (83)
  • Grafy zatwierdzeń (85)
  • Przedziały zatwierdzeń (89)
• Znajdowanie zatwierdzeń (93)
  
  • Użycie polecenia git bisect (93)
  • Użycie polecenia git blame (97)
  • Użycie kilofa (98)

7. Odgałęzienia (99)

• Powody stosowania odgałęzień (99)
• Nazwy odgałęzień (100)
  
  • Co używać, a czego nie używać w nazwach odgałęzień (101)
• Zastosowanie odgałęzień (101)
• Tworzenie odgałęzień (103)
• Sporządzanie wykazów nazw odgałęzień (104)
• Przeglądanie odgałęzień (104)
• Wyciąganie odgałęzień (106)
  
  • Elementarny przykład wyciągania odgałęzienia (107)
  • Wyciąganie w wypadku niezatwierdzonych zmian (107)
  • Łączenie zmian w nowe odgałęzienie (109)
  • Tworzenie i wyciąganie nowego odgałęzienia (111)
  • Wyosobnione odgałęzienia HEAD (111)
• Usuwanie odgałęzień (112)

8. Różnice (115)

• Postaci polecenia git diff (116)
• Prosty przykład polecenia git diff (120)
• Polecenie git diff i przedziały zatwierdzeń (122)
• Polecenie git diff z ograniczeniem ścieżki (125)
• Porównanie wyprowadzania różnic w systemach Subversion i Git (126)

9. Łączenia (129)

• Przykłady łączeń (129)
  
  • Przygotowanie do łączenia (130)
  • Łączenie dwóch odgałęzień (130)
  • Konflikt w trakcie łączenia (132)
• Postępowanie z konfliktami łączenia (135)
  
  • Lokalizowanie konfliktowych plików (136)
  • Badanie konfliktów (136)
  • W jaki sposób Git śledzi konflikty (140)
  • Zakończenie rozwiązywania konfliktu (142)
  • Zaniechanie lub wznowienie łączenia (143)
• Strategie łączenia (144)
  
  • Łączenia zdegenerowane (146)
  • Łączenia zwykłe (147)
  • Łączenia specjalne (149)
  • Stosowanie strategii łączenia (149)
  • Sterowniki łączenia (151)
• Jak Git rozpatruje łączenia (151)
  
  • Łączenia i model obiektowy Gita (151)
  • Łączenia zgniatane (152)
  • Czemu nie łączyć po prostu każdej zmiany po kolei? (153)

10. Zmienianie zatwierdzeń (155)

• Uwaga dotycząca zmieniania historii (157)
• Użycie polecenia git reset (158)
• Użycie polecenia git cherry-pick (164)
• Użycie polecenia git revert (166)
• Polecenia reset, revert i checkout (167)
• Zmiana zatwierdzenia szczytowego (168)
• Przebazowanie zatwierdzeń (170)
  
  • Użycie polecenia git rebase -i (172)
  • Operacja rebase a łączenie (176)

11. Skrytka stash i rejestr odniesień reflog (181)

• Skrytka (181)
• Rejestr odniesień (189)

12. Archiwa zdalne (193)

• Koncepcje archiwum (194)
  
  • Archiwa czyste i rozwojowe (194)
  • Klony archiwów (195)
  • Piloty (196)
  • Odgałęzienia nadzorujące (197)
• Odwoływanie się do innych archiwów (198)
  
  • Odwołania do archiwów zdalnych (198)
  • Refspec - specyfikator odniesienia (200)
• Przykład użycia zdalnych archiwów (202)
  
  • Tworzenie archiwum wzorcowego (203)
  • Uczyń swój własny początek zdalnym (204)
  • Prowadzenie prac we własnym archiwum (206)
  • Wypychanie zmian (206)
  • Dodawanie nowego wykonawcy (207)
  • Pobieranie uaktualnień archiwum (209)
• Cykl rozwoju zdalnego archiwum w ujęciu rysunkowym (214)
  
  • Klonowanie archiwum (214)
  • Historie alternatywne (215)
  • Niespieszne wypychanie (216)
  • Pobieranie alternatywnej historii (217)
  • Łączenie historii (218)
  • Konflikty łączenia (218)
  • Wypychanie połączonej historii (219)
• Konfigurowanie zdalne (219)
  
  • Użycie polecenia git remote (220)
  • Użycie polecenia git config (221)
  • Obróbka ręczna (222)
• Działanie na odgałęzieniach nadzorowania (222)
  
  • Tworzenie gałęzi nadzorowania (222)
  • Przed i za (225)
• Dodawanie i usuwanie odgałęzień zdalnych (226)
• Archiwa czyste i polecenie git push (227)

13. Zarządzanie archiwum (229)

• Słowo o serwerach (229)
• Publikowanie archiwów (230)
  
  • Archiwa z kontrolowanym dostępem (230)
  • Archiwa z anonimowym dostępem do czytania (231)
  • Archiwa z anonimowym dostępem do pisania (235)
  • Publikowanie archiwum na koncie GitHub (235)
• Wskazówka dotycząca publikowania archiwum (236)
• Struktura archiwum (237)
  
  • Struktura archiwum dzielonego (237)
  • Struktura archiwum rozproszonego (238)
  • Przykłady struktur archiwów (239)
• Jak żyć w warunkach rozproszenia (241)
  
  • Zmienianie historii upublicznionej (241)
  • Rozdzielność kroków zatwierdzeń i publikowania (242)
  • Ani jednej historii prawdziwej (242)
• Znaj swoje miejsce (243)
  
  • Przepływy w górę i w dół (244)
  • Role pielęgnatora i budowniczego (244)
  • Współpraca między pielęgnatorem a budowniczym (245)
  • Dualność ról (246)
• Praca z wieloma archiwami (247)
  
  • Twoja własna przestrzeń robocza (247)
  • Gdzie rozpocząć swoje archiwum (248)
  • Przekształcenie w inne archiwum w górze (249)
  • Używanie wielu górnych archiwów (250)
  • Rozwidlanie projektów (252)

14. Łaty (255)

• Dlaczego używamy łat? (256)
• Generowanie łat (257)
  
  • Łaty i sortowanie topologiczne (264)
• Pocztowe ekspediowanie łat (264)
• Stosowanie łat (267)
• Złe łaty (273)
• Łatanie a łączenie (273)

15. Doczepki (275)

• Instalowanie doczepek (277)
  
  • Doczepki przykładowe (277)
  • Utworzenie pierwszej doczepki (278)
• Dostępne doczepki (280)
  
  • Doczepki powiązane z zatwierdzeniami (280)
  • Doczepki powiązane z łatami (281)
  • Doczepki powiązane z wypychaniem (282)
  • Inne doczepki do lokalnego archiwum (283)

16. Zestawianie projektów (285)

• Stare rozwiązanie: wyciągi częściowe (286)
• Rozwiązanie oczywiste: zaimportuj kod do swojego projektu (287)
  
  • Importowanie podprojektów przez kopiowanie (289)
  • Importowanie podprojektów poleceniem git pull -s subtree (289)
  • Kierowanie swoich zmian w górę (293)
• Rozwiązanie zautomatyzowane: wyciąganie podprojektów z użyciem odpowiednich skryptów (293)
• Rozwiązanie rodzime: gitlinki i git submodule (295)
  
  • Odsyłacze gitlinks (295)
  • Polecenie git submodule (297)

17. Najlepsze praktyki dotyczące podmodułów (301)

• Polecenia podmodułowe (301)
• Dlaczego podmoduły? (302)
• Przygotowywanie podmodułów (303)
• Dlaczego tylko do czytania? (304)
• Dlaczego nie tylko do czytania? (304)
• Sprawdzanie haszowań zatwierdzeń podmodułów (305)
• Ponowne wykorzystanie pełnomocnictw (305)
• Przypadki użycia (306)
• Wielopoziomowe zagnieżdżanie archiwów (307)
• Podmoduły na horyzoncie (307)

18. Zastosowanie Gita do archiwów systemu Subversion (309)

• Przykład: płytki klon jednego odgałęzienia (309)
  
  • Pora na wykonywanie zmian w Gicie (312)
  • Pobranie przed zatwierdzeniem (313)
  • Zatwierdzanie za pomocą git svn rebase (314)
• Wypychanie, ciągnięcie, rozgałęzianie i łączenie za pomocą git svn (315)
  
  • Utrzymywanie prostoty identyfikatorów zatwierdzeń (316)
  • Klonowanie wszystkich gałęzi (317)
  • Dzielenie Twojego archiwum (319)
  • Ponowne włączanie do Subversion (320)
• Inne uwagi o pracy z systemem Subversion (321)
  
  • Cecha svn:ignore a plik .gitignore (321)
  • Rekonstruowanie pamięci podręcznej git-svn (322)

19. Działania zaawansowane (323)

• Użycie polecenia git filter-branch (323)
  
  • Przykłady użycia polecenia git filter-branch (325)
  • Pułapki filter-branch (330)
• Jak pokochałem polecenie git rev-list (330)
  
  • Wyciąganie według daty (331)
  • Odzyskiwanie starej wersji pliku (333)
• Interaktywne wystawianie kawałków (335)
• Rekonstruowanie utraconego zatwierdzenia (345)
  
  • Polecenie git fsck (345)
  • Ponowne przyłączenie utraconego zatwierdzenia (349)

20. Rady, chwyty i sposoby (351)

• Interaktywne przebazowanie z zabrudzonym katalogiem roboczym (351)
• Usuwanie zbędnych plików edytora (352)
• Łączenie nieużytków (352)
• Podział archiwum (354)
• Sposoby rekonstruowania zatwierdzeń (355)
• Rady dotyczące konwersji Subversion (356)
  
  • Ogólne zalecenia (356)
  • Usuwanie trzonu po zaimportowaniu SVN (356)
  • Usuwanie identyfikatorów zatwierdzeń SVN (357)
• Manipulowanie odgałęzieniami pochodzącymi z dwu archiwów (357)
• Odzyskiwanie z przebazowania w górze (358)
• Tworzenie własnych poleceń w Gicie (359)
• Szybki przegląd zmian (360)
• Czyszczenie (361)
• Użycie polecenia git-grep do przeszukiwania archiwum (361)
• Aktualizowanie i usuwanie refów (363)
• Postępowanie za przemieszczonymi plikami (364)
• Zachowaj ten plik, lecz go nie nadzoruj (365)
• Byłeś tu już wcześniej? (366)

21. Git i GitHub (367)

• Archiwum kodu powszechnie dostępnego (367)
• Tworzenie archiwum w GitHubie (369)
• Kodowanie społeczne na otwartych źródłach (372)
• Obserwatorzy (373)
• Kanał informacyjny (373)
• Rozwidlenia (374)
• Przygotowywanie zamówień ciągnięcia (376)
• Obsługiwanie zamówień ciągnięcia (377)
• Powiadomienia (379)
• Odnajdywanie użytkowników, projektów i kodu (382)
• Wikisy (383)
• Strony GitHuba (Git do witryn) (384)
• Edytor kodu wprost ze strony (386)
• Most do systemu Subversion (388)
• Metki automatycznie zamieniane na pliki archiwalne (389)
• Organizacje (390)
• Interfejs REST API (390)
• Kodowanie społeczne oparte na źródłach zamkniętych (391)
• Docelowe czerpanie z otwartych źródeł (392)
• Modele kodowania (393)
• GitHub jako inicjatywa gospodarcza (395)
• GitHub - podsumowanie (396)

Skorowidz (397)