-***- Programming Cloud Native Network Services in Go (VITMMA22)  -***-

1. *Cloud Native Go.* General information. Cloud native design: motivations, platform as a service
   and promises of cloud computing, the pets vs. cattle dichotomy, cloud-native definition. The
   five pillars of a cloud-native application: scalability, loose coupling, resilience,
   manageability, and observability. Go for cloud native development: composition and structural
   typing, comprehensibility, concurrency, fast builds, linguistic stability, memory safety,
   performance, static linking, static typing.

2. *Go Language Foundations 1.* Basic data types: booleans, numbers and strings. Variables:
   declaration, zero values, the blank identifier, constants, enums. Container types: arrays,
   slices, maps, operators on slices and maps. Pointers. Control structures: loops constructs and
   conditional statements. Error handling. The anatomy of a Go program.

3. *Go Language Foundations 2.* Functions: declaration, multiple return values, defer, calling
   functions with values or references, variadics, anonymous functions and closures. Structs,
   methods, and interfaces, shallow and deep copy, value and pointer receivers, polymorphism with
   interfaces, type assertions. Composition: embedding and promotion. A case study.

4. *Go Language Foundations 3.* Modules and packages: declaration, metadata, importing and
   exporting, godoc, overriding package imports with replace. Concurrency: goroutines, the CSP
   model, buffered and unbuffered channels, range and select on channels, the context package,
   explicit synchronization with locks/mutexes, a case study.

5. *The Anatomy of a Web Service.* Web Applications: a sample "leaderboard" web app. Web Tooling in
   Go: HTTP servers, handlers and clients. Working with JSON: struct tags, marshaling and
   unmarshaling JSON. An example: the Data Layer and the HTTP Server. Testing. Deploying to

6. *Cloud Native Patterns 1: Immutability.* Cloud native design: microservices, the 10 fallacies of
   distributed computing, principles and best-practices. The immutability pattern: persistence and
   state externalization, application vs. resource state, RESTful design. Implementing persistence:
   transaction logs, mutating and non-mutating operations on state, implementing a "transactionlog"
   package, integration with the leaderboard web app.

7. *Cloud Native Patterns 2: Loose coupling.* Persistence in Kubernetes: containerization and
   vendoring, Kubernetes manifests, using persistent volumes. State externalization: consistent and
   persistent external data stores, integrating the "leaderboard" app with Redis. Structuring Go
   code. The loose coupling pattern: loose coupling antipatterns, loosely coupled data models and
   NoSQL, API design for loose coupling. Case study: a "kvstore" sample key-value store.

8. *Cloud Native Patterns 3: Idempotence.* Transactional state updates, the "versioned" key-value
   store, the "get-put" API, retriability. The idempotence pattern: idempotent APIs. Integrating
   the "leaderboard" with "kvstore", persistence, deploying to Kubernetes, testing. Loose coupling
   revisited: data schemata (or the lack, thereof), idempotence, API versioning, API grouping,

9. *Cloud Native Patterns 4: Client-side resilience.* Failures: simulating timeouts with fault
   injection, infinite retry loops, grey failures and "heisenbugs". The resiliency
   pattern. Client-side failure mitigation: timeout, retry, preventing retry storms, random
   exponential backoff, circuit breaking, composing resiliency patterns, sample code. Client-side
   overload prevention: debounce and rate-limiting. A case study: a resilient "leaderboard".

10. *Cloud Native Patterns 5: Server-side resilience.* Failure detection: health checking, shallow
    and deep health checks. Health checking in Kubernetes: readiness, liveness and startup
    probes. Server-side failure mitigation: graceful shutdown, pod lifecycle in Kubernetes, a case
    study. Server-side overload prevention: load-shedding, rate-limiting, atomic variables,

11. *Cloud Native Patterns 6: Scalability.* Scalability patterns: horizontal vs. vertical
    scaling. Scaling immutable services: resource requests/limits in Kubernetes, typical
    bottlenecks (CPU, memory and I/O bounded applications). The autoscaling pattern. Scaling
    mutable services: data sharding and role-based sharding, key-hashing, StatefulSets and headless
    Kubernetes services.

12. *Cloud Native Patterns 7: Manageability and Observability.* The manageability pattern:
    imperative and declarative management, reconciliation, the 4 rules for managing cloud-native
    applications. Managing Go applications: environment variables, configuration files and command
    line arguments, setting each in Kubernetes pod templates, ConfigMaps and Secrets. The
    observability pattern. Distributed tracing. Metrics, metric types, push/pull model, collectors
    and visualization. Logs, loglevels, structured logs, inspecting logs in Kubernetes, post-mortem
    analysis. Manageability and observability recipes.

13. *The Service Mesh: Automating cloud native patterns.* The service mesh: polyglot applications,
    the service mesh pattern, mesh libraries and the sidecar proxy architecture. Traffic
    management, resiliency, access control, encryption, observability, and fault-injection using
    Istio. The twelve-factor app.

14. *Resources*