Intermediate Go Programming in Africa: APIs & Concurrency

Course outline and learning expectations

This is a tutor-led course. The outline shows what your tutor will cover; teaching materials and examinations are provided directly to enrolled students.

What you will learn

• By the end of this course, the learner will be able to:
• Design idiomatic package boundaries and maintainable Go APIs.
• Use goroutines and channels to coordinate concurrent work.
• Apply `select`, cancellation, timeouts and `context` safely.
• Protect shared state with mutexes and other synchronisation tools.
• Detect and correct data races with Go’s race detector.
• Apply generics when they improve reuse without reducing clarity.
• Build JSON HTTP services using Go’s standard library.
• Implement routing, middleware, validation and consistent error responses.
• Write unit, HTTP, integration-style and fuzz tests.
• Use benchmarks and profiling evidence to investigate performance.
• Check Go dependencies for known vulnerabilities.
• Build and document a tested intermediate Go service for an African business or public-service scenario.

Modules

1. 1

   Idiomatic design for larger Go programs

   Package responsibilities and dependency directionPublic APIs and exported typesComposition over inheritanceDependency injection with functions and small interfacesFunctional options where appropriateAvoiding package cycles and “utility” packagesRefactoring for clarity rather than abstractionReviewing code with Go conventions
2. 2

   Goroutines and channel fundamentals

   Concurrency versus parallelismStarting and stopping goroutinesUnbuffered and buffered channelsChannel directionClosing channels and ranging over resultsAvoiding goroutine leaksWorker and producer-consumer patternsPractice project: concurrent regional data-file processor
3. 3

   Coordination, cancellation and shared state

   `select` and non-blocking coordinationTimeouts and timersCancellation with `context`Propagating request-scoped values responsibly`sync.WaitGroup`, `sync.Mutex`, `sync.RWMutex` and `sync.Once`Choosing channels versus mutexesUsing the race detectorPractice project: cancellable multi-source report generator
4. 4

   Generics and reusable algorithms

   Type parameters and constraintsGeneric functionsGeneric typesThe `comparable` constraintType approximationWhen interfaces are a better choiceWhen generics add unnecessary complexityPractice project: typed filtering, mapping and aggregation helpers
5. 5

   HTTP and JSON with the Go standard library

   HTTP clients and serversHandlers and routing with `net/http`Request methods, headers and status codesEncoding and decoding JSONInput limits and validationConsistent success and error responsesServer timeoutsGraceful shutdown conceptsPractice project: local-service directory API
6. 6

   Middleware and service structure

   Handler compositionLogging and request identifiersPanic recovery at service boundariesBasic cross-origin request conceptsConfiguration through environment variablesSeparating transport and business logicRepository-style boundaries without a database dependencyAPI documentation and runnable examplesPractice project: extend an SME or public-information service
7. 7

   Advanced testing, security and performance

   HTTP handler tests with `httptest`Test doubles using functions and small interfacesIntegration-style testsFuzz testing and edge-case discoveryBenchmarks and allocation reportsCPU and memory profilingAvoiding premature optimisationDependency and vulnerability checks with `govulncheck`Testing concurrent code and checking for races
8. 8

   Intermediate capstone service

   Defining a small service contractDesigning packages and interfacesBuilding CRUD-style JSON endpointsAdding validation and structured errorsApplying concurrency to a justified workloadImplementing cancellation and server timeoutsWriting handler, fuzz and business-logic testsRunning race, vet and vulnerability checksPublishing setup instructions, endpoint examples and technical decisions