Nauka programowania w Go - Plan Szkolenia

1. Wprowadzenie do Go

• Czym jest Go (Golang)?
• Historia i filozofia projektowania Go
• Go jako język programowania do tworzenia aplikacji internetowych i systemowych
• Kluczowe cechy:
  • Statyczne typowanie
  • Prostota i czytelność
  • Szybka kompilacja
  • Wbudowana współbieżność
  • Odbieranie śmieci (garbage collection)
  • Platformowe kompilowanie (cross-compilation)
• Powszechne przypadki zastosowania Go
• Zalety i ograniczenia Go
• Porównanie Go z C/C++, JavaScript, Ruby, Python i Java
• Zrozumienie ekosystemu Go
• Przegląd standardowej biblioteki Go
• Moduły Go i zarządzanie zależnościami
• Struktura aplikacji Go
• Praca praktyczna: Analiza i uruchomienie prostego programu w Go

2. Konfiguracja środowiska programistycznego Go

• Instalacja Go
• Znajomość zestawu narzędzi Go (toolchain)
• Konfigurowanie zmiennych środowiskowych
• Wybór IDE lub edytora kodu
• Praca w linii poleceń z Go
• Tworzenie przestrzeni roboczej Go (workspace)
• Zrozumienie struktury projektu Go
• Inicjalizacja projektu za pomocą Go Modules
• Używanie go mod init
• Zarządzanie zależnościami za pomocą go get
• Aktualizowanie i inspektowanie zależności
• Formatowanie kodu źródłowego za pomocą gofmt
• Uruchamianie programów za pomocą go run
• Budowanie aplikacji za pomocą go build
• Instalacja aplikacji Go
• Kompilacja międzyplatformowa
• Praca praktyczna: Utworzenie i skonfigurowanie projektu Go wewnątrz kontenera

3. Zmienne, stałe i typy w Go

• Deklarowanie zmiennych
• Typy jawne w porównaniu z wywnioskowanymi
• Skrócone deklaracje zmiennych
• Stałe
• Wartości zerowe
• Zakres i czas życia zmiennych
• Elementarne typy danych:
  • Liczby całkowite
  • Liczby zmiennoprzecinkowe
  • Liczby zespolone
  • Wartości logiczne
  • Łańcuchy znaków
• Konwersje typów
• Praca z Unicode i UTF-8
• Runesy i bajty
• Wielokrotne przypisywanie wartości zmiennym
• Zrozumienie bezpieczeństwa typów
• Ćwiczenie: Stworzenie małego programu przetwarzającego dane w linii poleceń

4. Operatory i wyrażenia

• Operatory arytmetyczne
• Operatory porównania
• Operatory logiczne
• Operatory przypisania
• Inkrementacja i dekrementacja
• Priorytet operatorów
• Obliczenia na liczbach całkowitych i zmiennoprzecinkowych
• Unikanie powszechnych błędów konwersji typów
• Ćwiczenie: Zaimplementowanie logiki obliczeń i walidacji

5. Daty, czasy i formatowanie

• Wykorzystywanie pakietu time
• Tworzenie i manipulowanie datami
• Pobieranie aktualnego czasu
• Strefy czasowe i lokalizacje
• Analiza (parsing) dat i czasu
• Formatowanie dat i czasu
• Obliczanie różnic czasowych (durations)
• Praca ze znacznikami czasu Unix
• Obsługa limitów czasu (timeoutów)
• Ćwiczenie: Dodanie znaczników czasu i obliczeń różnic czasowych do aplikacji

6. Tablice, tablice dynamiczne (slices), mapy i struktury

Tablice

• Deklarowanie tablic
• Inicjalizacja tablic
• Iterowanie po tablicach
• Tablice wielowymiarowe

Tablice dynamiczne (Slices)

• Różnice między tablicami a slices
• Tworzenie slices
• Dodawanie elementów
• Kopiowanie slices
• Długość i pojemność slices
• Wycinki slices (slicing)
• Powszechne pułapki związane z slices

Mapy

• Tworzenie map
• Dodawanie i usuwanie wpisów
• Sprawdzanie istnienia klucza
• Iterowanie po mapach
• Mapy zawierające złożone dane

Struktury

• Definiowanie struktur

• Pola struktur

• Inicjalizacja struktur

• Zagnieżdżone struktury

• Struktury anonimowe

• Metody struktur

• Tagi JSON dla struktur

• Praca praktyczna: Modelowanie użytkowników, produktów i danych aplikacji przy użyciu struktur, slices i map

7. Logika warunkowa i pętle

• Instrukcje if
• else oraz else if
• Deklarowanie zmiennych w warunkach
• Pętle for
• Pętle nieskończone
• Warunki pętli
• break oraz continue
• Iterowanie przy użyciu range
• Zagnieżdżone pętle
• Instrukcje switch
• Przełączniki oparte na wyrażeniach
• Wielokrotne przypadki
• Domyślny przypadek
• Przełączniki typów (type switches)
• Ćwiczenie: Zaimplementowanie logiki walidacji i przetwarzania aplikacji

8. Funkcje

• Definiowanie funkcji
• Parametry funkcji
• Wartości zwracane
• Wielokrotne wartości zwracane
• Nazwane wartości zwracane
• Funkcje zmiennoliczbowe (variadic)
• Funkcje anonimowe
• Wartości funkcji
• Zamknięcia (closures)
• Rekursja
• Podawanie funkcji jako argumentów
• Funkcje zwracające błędy
• Projektowanie małych, ponownie używalnych funkcji
• Ćwiczenie: Refaktoryzacja istniejącego kodu na ponownie używalne funkcje

9. Wskaźniki i koncepcje pamięci

• Czym jest wskaźnik?
• Operatory pobierania adresu i odwołania (dereference)
• Wskaźniki i parametry funkcji
• Wskazujące odbiorcy (pointer receivers)
• Wskaźniki do struktur
• Wskaźniki zerowe (nil pointers)
• Kiedy używać wskaźników
• Semantyka wartości w porównaniu z referencją
• Zrozumienie zarządzania pamięcią w Go i odbierania śmieci
• Powszechne błędy związane z wskaźnikami
• Praca praktyczna: Modyfikowanie danych aplikacji za pomocą wskaźników

10. Tworzenie aplikacji internetowej w Go

• Przegląd możliwości webowych Go
• Wprowadzenie do pakietu net/http
• Tworzenie serwera HTTP
• Zapytania i odpowiedzi HTTP
• Metody HTTP
• Adresy URL i parametry zapytań
• Nagłówki HTTP
• Kody statusu HTTP
• Podstawy routingu
• Tworzenie obsłużników (handlers)
• Przetwarzanie danych formularza
• Serwowanie plików statycznych
• Praca z szablonami HTML
• Zmienne szablonowe i struktury sterujące
• Strukturyzowanie aplikacji internetowej
• Praca praktyczna: Zbudowanie podstawowego serwera internetowego w Go

11. Budowanie usług sieciowych RESTful

• Podstawy architektury REST
• Projektowanie punktów końcowych API
• GET, POST, PUT, PATCH i DELETE
• Praca z JSON
• Kodowanie i dekodowanie JSON
• Walidacja zapytań
• Kody statusu HTTP
• Odpowiedzi z błędami
• Parametry zapytań i parametry ścieżki
• Struktury odpowiedzi API
• Odróżnianie obsłużników od logiki biznesowej
• Praca praktyczna: Zbudowanie CRUD REST API

12. Interfejs programowania (Runtime), kompilacja i budowanie projektów Go

• Zrozumienie kompilatora Go
• Proces budowania w Go
• go run
• go build
• go install
• go test
• Flagi budowania
• Konfiguracja specyficzna dla środowiska
• Budowanie dla różnych systemów operacyjnych i architektur
• Tworzenie samodzielnych binariów
• Zarządzanie konfiguracją aplikacji
• Ćwiczenie: Skompilowanie aplikacji dla wielu platform

13. Praca z plikami i webem

• Otwieranie i zamykanie plików
• Czytanie plików
• Zapisywanie plików
• Tworzenie katalogów
• Metadane plików
• Buforowane I/O
• Praca z potokami (streams)
• Czytanie i zapisywanie plików JSON
• Klienty HTTP
• Wysyłanie zapytań HTTP
• Obsługa błędów klienta HTTP
• Limity czasu i anulowanie
• Przetwarzanie odpowiedzi API
• Praca praktyczna: Pobieranie danych z zewnętrznego API i ich lokalne utrwalanie

14. Obsługa błędów i debugowanie

• Podejście Go do błędów
• Zwracanie błędów z funkcji
• Sprawdzanie błędów
• Tworzenie niestandardowych błędów
• OWIJANIE błędów (wrapping errors)
• Dodawanie kontekstu do błędów
• errors.Is oraz errors.As
• panic i recovery
• Kiedy używać panic
• Debugowanie powszechnych problemów w Go
• Rejestrowanie aktywności aplikacji
• Wykorzystywanie narzędzi do debugowania Go
• Ćwiczenie: Diagnozowanie i naprawa celowo wprowadzonych błędów aplikacji

15. Interfejsy i abstrakcja

• Czym jest interfejs?
• Implikowane implementacje interfejsów
• Definiowanie interfejsów
• Wartości interfejsów
• Puste interfejsy / any
• Asercje typów
• Przełączniki typów
• Implementacje przez wskaźnik w porównaniu z wartością
• Projektowanie małych interfejsów
• Inwersja zależności
• Używanie interfejsów do testowania
• Zmniejszanie sprzężenia aplikacji
• Praca praktyczna: Wprowadzenie interfejsów w przykładowej aplikacji internetowej

16. Pakiety i organizacja projektu

• Tworzenie pakietów
• Zasady nazywania pakietów
• Identyfikatory eksportowane i nieeksportowane
• Importowanie pakietów
• Inicjalizacja pakietów
• Organizacja warstw aplikacji
• Pakiety wewnętrzne
• Zarządzanie zależnościami za pomocą Go Modules
• Semantyczne wersjonowanie
• Używanie pakietów zewnętrznych
• Unikanie zależności cyklicznych
• Projektowanie utrzymywalnych projektów Go
• Ćwiczenie: Refaktoryzacja aplikacji na osobne pakiety

17. Współbieżność z Goroutines

• Czym jest współbieżność?
• Goroutines
• Rozpoczynanie goroutines
• Zrozumienie lekkiej współbieżnej egzekucji
• Wyzwania synchronizacji
• Współdzielone stany
• Synergie (race conditions)
• Używanie sync.WaitGroup
• Mutueksy i mutueksy odczytu/zapisu
• Operacje atomowe
• Praca praktyczna: Konwersja zadania sekwencyjnego na równoległe przetwarzanie

18. Kanały (Channels)

• Zrozumienie kanałów
• Wysyłanie i odbieranie wartości
• Kanały buforowane i niebuforowane
• Zachowanie blokujące
• Zamykanie kanałów
• Iterowanie po kanałach
• Kanały kierunkowe
• Komunikacja oparta na kanałach
• Instrukcje select
• Limity czasu i anulowanie
• Wzorce puli pracowników (worker-pool)
• Wzorce producent/konsument
• Praca praktyczna: Zbudowanie równoległego systemu pracowników

19. Kontekst i zarządzanie zapytaniami

• Dlaczego konteksty są ważne w aplikacjach internetowych
• context.Context
• Kontekst zakresu zapytania
• Anulowanie
• Terminy (deadlines)
• Limity czasu
• Przepuszczanie kontekstu przez warstwy aplikacji
• Anulowanie operacji bazy danych lub HTTP
• Unikanie błędnego użycia kontekstu
• Ćwiczenie: Dodanie anulowania zapytań i limitów czasu do aplikacji internetowej

20. Testowanie aplikacji Go

• Dlaczego automatyzacja testów jest ważna
• Pisanie testów jednostkowych
• Pakiet testing
• Funkcje testowe
• Zasady nazywania testów
• Testy oparte na tabelach
• Testowanie błędów
• Testowanie obsłużników HTTP
• Serwery testowe HTTP
• Fiksy testowe (test fixtures)
• Zakrycie testami
• Testy wydajnościowe (Benchmarks)
• Testy przykładowe
• Testowanie interfejsów za pomocą mocków lub fałszywych implementacji
• Praca praktyczna: Utworzenie pakietu testów dla przykładowej aplikacji

21. Optymalizacja wydajności

• Zrozumienie wydajności aplikacji Go
• Identyfikacja wąskich gardeł
• Wydajność CPU w porównaniu z pamięcią
• Skuteczne struktury danych
• Zmniejszenie niepotrzebnych alokacji
• Łańcuchy znaków, bajty i bufora
• Zarządzanie goroutines
• Unikanie nadmiernej współbieżności
• Strategie cache
• Względy dotyczące bazy danych i sieci
• Profilowanie aplikacji
• Testy wydajnościowe i benchmarki
• Wykorzystywanie narzędzi do profilowania Go
• Ćwiczenie: Profilowanie i optymalizacja celowo nieefektywnej aplikacji

22. Bezpieczeństwo i solidne praktyki tworzenia aplikacji internetowych

• Walidacja danych wejściowych użytkownika
• Bezpieczna obsługa zapytań HTTP
• Przypadki powszechnych luk bezpieczeństwa w webie
• Bezpieczna obsługa błędów
• Koncepcje uwierzytelniania i autoryzacji
• Zarządzanie sekretami i konfiguracją
• Bezpieczna komunikacja HTTP
• Unikanie wrażliwych informacji w logach
• Zarządzanie zależnościami i aktualizacje
• Limity zasobów i limity czasu zapytań
• Ćwiczenie: Przegląd i wzmocnienie przykładowego API

23. Logowanie aplikacji i obserwowalność

• Podstawy logowania
• Logowanie strukturalne
• Poziomy logów
• Logowanie zapytań
• Logowanie błędów
• Skorelowanie i identyfikatory zapytań
• Monitorowanie zachowania aplikacji
• Podstawowe metryki
• Punkty końcowe sprawdzania stanu zdrowia (health-check)
• Diagnozowanie problemów produkcyjnych
• Praca praktyczna: Dodanie strukturalnego logowania i sprawdzania stanu zdrowia

24. Konteneryzacja aplikacji Go

• Dlaczego używać kontenerów?
• Aplikacje Go i konteneryzacja
• Pisanie pliku Dockerfile
• Budowanie wieloetapowe
• Tworzenie minimalistycznego obrazu środowiska wykonawczego
• Zarządzanie konfiguracją za pomocą zmiennych środowiskowych
• Sieciowanie kontenerów
• Eksponowanie portów aplikacji
• Uruchamianie aplikacji w kontenerze
• Testowanie aplikacji konteneryzowanej
• Praca praktyczna: Spakowanie przykładowej aplikacji Go jako kontenera gotowego do produkcji

25. Wdrożenie (Deployment)

• Przygotowanie aplikacji do środowiska produkcyjnego
• Budowanie binariów produkcyjnych
• Konfiguracja środowiska
• Wdrożenie oparte na kontenerach
• Architektura wdrożenia
• Proxy odwrotne
• Rozważania dotyczące HTTPS/TLS
• Sprawdzanie stanu zdrowia aplikacji
• Łagodne wygaszanie (Graceful shutdown)
• Obsługa sygnałów systemu operacyjnego
• Skalowanie aplikacji internetowych Go
• Skalowanie poziome w porównaniu z pionowym
• Podstawowe rozwiązywanie problemów przy wdrożeniach
• Praca praktyczna: Wdrożenie przykładowej aplikacji internetowej

26. Projekt końcowy: Kompletna aplikacja internetowa Go

Uczestnicy łączą ze sobą poznane koncepcje, tworząc kompletną aplikację.

Projekt może obejmować:

• Inicjalizację projektu za pomocą Go Modules
• Organizację pakietów
• Routing HTTP
• Punkty końcowe API REST
• Obsługę zapytań i odpowiedzi JSON
• Walidację danych wejściowych
• Obsługę błędów
• Interfejsy
• Równoległe przetwarzanie
• Komunikację z zewnętrznymi API
• Utrwalanie danych w plikach lub bazie danych
• Automatyczne testy
• Logowanie
• Względy wydajnościowe
• Konteneryzacja
• Konfiguracja produkcyjna
• Wdrożenie

27. Przegląd i najlepsze praktyki

• Przegląd składni podstawowej Go
• Zasady kodowania w Go
• Pisanie idiomy Go
• Trzymanie kodu prostym
• Skuteczne projektowanie pakietów
• Najlepsze praktyki obsługi błędów
• Zasady projektowania interfejsów
• Najlepsze praktyki współbieżności
• Strategie testowania
• Względy wydajnościowe
• Utrzymywalność i czytelność
• Powszechne błędy popełniane przez początkujących programistów Go
• Zalecane podejścia do dalszego rozwoju w Go

28. Podsumowanie

• Przegląd kluczowych koncepcji
• Przegląd ukończonej aplikacji internetowej
• Pytania i dyskusja
• Rozwiązywanie powszechnych problemów realnych
• Zalecane kolejne kroki w rozwoju Go
• Dodatkowe biblioteki Go i zasoby ekosystemu
• Dalsze możliwości budowy usług Go gotowych do produkcji