🥋 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.

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?

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

Create a new folder XX-your-topic. (XX is an ordinal number)
Copy the README_TEMPLATE.md to the new folder as README.md
Define the challenge: focus on real-world scenarios (e.g., handling timeouts, zero-allocation sets), and idiomatic Go, not just algorithmic puzzles.
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
Submit a PR.

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

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

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

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

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

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