🥋 Go Katas 🥋

"I fear not the man who has practiced 10,000 kicks once, but I fear the man who has practiced one kick 10,000 times." (Bruce Lee)

What should it be?

• Go is simple to learn, but nuanced to master. The difference between "working code" and "idiomatic code" often lies in details such as safety, memory efficiency, and concurrency control.

• This repository is a collection of Daily Katas: small, standalone coding challenges designed to drill specific Go patterns into your muscle memory.

What should it NOT be?

• This is not intended to teach coding, having Go as the programming mean. Not even intended to teach you Go in general
• The focus should be as much as possible challenging oneself to solve common software engineering problems the Go way.
• Several seasoned developers spent years learning and applying best-practices at prod-grade context. Once they decide to switch to go, they would face two challanges:
  • Is there a window of knowledge transform here, so that I don't have to through years of my career from the window at start from zero?
  • If yes, the which parts should I focus on to recognize the mismatches and use them the expected way in the Go land?

How to Use This Repo

1. Pick a Kata: Navigate to any XX-kata-yy folder.
2. Read the Challenge: Open the README.md inside that folder. It defines the Goal, the Constraints, and the "Idiomatic Patterns" you must use.
3. Solve It: Initialize a module inside the folder and write your solution.
4. Reflect: Compare your solution with the provided "Reference Implementation" (if available) or the core patterns listed.

Contribution Guidelines

Have a favorite Go pattern?

1. Create a new folder XX-your-topic. (XX is an ordinal number)
2. Copy the README_TEMPLATE.md to the new folder as README.md
3. Define the challenge: focus on real-world scenarios (e.g., handling timeouts, zero-allocation sets), and idiomatic Go, not just algorithmic puzzles.
4. Optionally, create a main.go or any other relevant files under the project containing blueprint of the implementation, as long as you think it reduces confusion and keeps the implementation focused
5. Submit a PR.

Katas Index (Grouped)

01) Context, Cancellation, and Fail-Fast Concurrency

Real-world concurrency patterns that prevent leaks, enforce backpressure, and fail fast under cancellation.

• 01 - The Fail-Fast Data Aggregator
• 03 - Graceful Shutdown Server
• 05 - Context-Aware Error Propagator
• 07 - The Rate-Limited Fan-Out Client
• 09 - The Cache Stampede Shield (singleflight TTL)
• 10 - Worker Pool with Backpressure and errors.Join
• 14 - The Leak-Free Scheduler
• 17 - Context-Aware Channel Sender (No Leaked Producers)

---

02) Performance, Allocation, and Throughput

Drills focused on memory efficiency, allocation control, and high-throughput data paths.

• 02 - Concurrent Map with Sharded Locks
• 04 - Zero-Allocation JSON Parser
• 11 - NDJSON Stream Reader (Long Lines)
• 12 - sync.Pool Buffer Middleware

---

03) HTTP and Middleware Engineering

Idiomatic HTTP client/server patterns, middleware composition, and production hygiene.

• 06 - Interface-Based Middleware Chain
• 16 - HTTP Client Hygiene Wrapper

---

04) Errors: Semantics, Wrapping, and Edge Cases

Modern Go error handling: retries, cleanup, wrapping, and infamous pitfalls.

• 08 - Retry Policy That Respects Context
• 19 - The Cleanup Chain (defer + LIFO + Error Preservation)
• 20 - The “nil != nil” Interface Trap (Typed nil Errors)

---

05) Filesystems, Packaging, and Deployment Ergonomics

Portable binaries, testable filesystem code, and dev/prod parity.

• 13 - Filesystem-Agnostic Config Loader (io/fs)
• 18 - embed.FS Dev/Prod Switch

---

06) Testing and Quality Gates

Idiomatic Go testing: table-driven tests, parallelism, and fuzzing.

• 15 - Go Test Harness (Subtests, Parallel, Fuzz)