Go: systems and services

The course, in order

Open a unit in the map to inspect its activities. Reading, guided completion, independent work and review remain distinct evidence.

1. Keep exact values and inspectable errors

   Validate exact value domains before evaluation, preserve zero values where valid, and keep wrapped Go error identity useful without accepting a typed nil.

   Open this unit
2. Separate bytes, runes, captures and record endings

   Process UTF-8 and borrowed record slices without confusing storage offsets, code points, capture participation or delimiter bytes.

   Open this unit
3. Own the storage behind a Go collection

   Preserve zero-value usability, absence, encounter order and caller ownership across slices, maps and generic collection operations.

   Open this unit
4. Own the opened object and publish only complete files

   Confine file acquisition to an owned directory handle, settle every opened resource, and replace output only after complete prepared-file publication.

   Open this unit
5. Preserve types behind narrow generic APIs

   Use type parameters, underlying-type constraints and caller-owned interfaces without erasing concrete results or admitting invalid map keys.

   Open this unit
6. Account for every byte before interpreting I/O status

   Honor Go reader and writer progress, hard byte limits and terminal errors without discarding accepted data or presenting a partial stream as complete.

   Open this unit
7. Accept one unambiguous serialized document

   Preserve exact number spelling and struct visibility while rejecting duplicate fields, invalid UTF-8, trailing documents and ambiguous exported schemas.

   Open this unit
8. Make ordering and interval policy explicit

   Transform caller-owned collections without aliasing or reordering surprises, and encode tie and interval semantics directly in comparisons.

   Open this unit
9. Resolve presence before applying defaults

   Keep absent, present-empty, explicit-zero and repeated configuration states distinct across maps, environment input and command arguments.

   Open this unit
10. Classify directory entries without following them

    Build deterministic file inventories from acquired metadata, keep each resource lifetime short and never publish a partial walk as complete.

    Open this unit
11. Keep web text in its declared grammar and trust domain

    Preserve repeated query values, escape untrusted markup, normalize timestamps deliberately and retain the difference between missing and empty captures.

    Open this unit
12. Cancel blocked edges and join every goroutine

    Bound admitted work, make both receives and sends cancellation-aware, retain the triggering error, and wait for every started goroutine before returning.

    Open this unit
13. Keep protocol decisions outside committed service state

    Enforce HTTP method, media, size and decoding boundaries before service effects, then make repeated command identity preserve one accepted effect.

    Open this unit
14. Prove both the answer and the work bound

    Guard exact numeric boundaries and implement search or dynamic programming with an instrumented amount of work rather than a plausible result alone.

    Open this unit
15. Publish initialized and cached state only after its owner commits

    Make one-time results, including failure, visible consistently and prevent a cache from advertising work its durable owner rejected.

    Open this unit
16. Inject time and stop at the declared budget

    Classify retryable failure, count attempts exactly, make waiting cancelable and test rate windows with an explicit clock instead of sleeps.

    Open this unit
17. Spend one network deadline across acquisition and I/O

    Frame portable network data, complete short transfers and keep address identity, socket ownership and one absolute deadline explicit.

    Open this unit
18. Verify the entire encoded object

    Distinguish canonical encoding, bounded expansion, corruption detection and authentication, and return no partial plaintext after rejection.

    Open this unit
19. Settle every acquired effect without hiding failure

    Use defer, joined errors and reverse compensation so owned cleanup runs exactly once on success and failure while every error identity remains inspectable.

    Open this unit
20. Make shared-state evidence match the work performed

    Perform real concurrent updates through one synchronization rule, publish detached snapshots, and make invalid admission produce no callback or partial state.

    Open this unit