Effective Go Style Guide Summary

This document summarizes key rules and best practices from the official "Effective Go" guide for writing idiomatic Go code.

1. Formatting

gofmt: All Go code must be formatted with gofmt (or go fmt). This is a non-negotiable, automated standard.
Indentation: Use tabs for indentation (gofmt handles this).
Line Length: Go has no strict line length limit. Let gofmt handle line wrapping.

MixedCaps: Use MixedCaps or mixedCaps for multi-word names. Do not use underscores.
Exported vs. Unexported: Names starting with an uppercase letter are exported (public). Names starting with a lowercase letter are not exported (private).
Package Names: Short, concise, single-word, lowercase names.
Getters: Do not name getters with a Get prefix. A getter for a field named owner should be named Owner().
Interface Names: One-method interfaces are named by the method name plus an -er suffix (e.g., Reader, Writer).

if: No parentheses around the condition. Braces are mandatory. Can include an initialization statement (e.g., if err := file.Chmod(0664); err != nil).
for: Go's only looping construct. Unifies for and while. Use for...range to iterate over slices, maps, strings, and channels.
switch: More general than in C. Cases do not fall through by default (use fallthrough explicitly). Can be used without an expression to function as a cleaner if-else-if chain.

Multiple Returns: Functions can return multiple values. This is the standard way to return a result and an error (e.g., value, err).
Named Result Parameters: Return parameters can be named. This can make code clearer and more concise.
defer: Schedules a function call to be run immediately before the function executing defer returns. Use it for cleanup tasks like closing files.

new vs. make:
- new(T): Allocates memory for a new item of type T, zeroes it, and returns a pointer (*T).
- make(T, ...): Creates and initializes slices, maps, and channels only. Returns an initialized value of type T (not a pointer).
Slices: The preferred way to work with sequences. They are more flexible than arrays.
Maps: Use the "comma ok" idiom to check for the existence of a key: value, ok := myMap[key].

Implicit Implementation: A type implements an interface by implementing its methods. No implements keyword is needed.
Small Interfaces: Prefer many small interfaces over one large one. The standard library is full of single-method interfaces (e.g., io.Reader).

Share Memory By Communicating: This is the core philosophy. Do not communicate by sharing memory; instead, share memory by communicating.
Goroutines: Lightweight, concurrently executing functions. Start one with the go keyword.
Channels: Typed conduits for communication between goroutines. Use make to create them.

error type: The built-in error interface is the standard way to handle errors.
Explicit Error Handling: Do not discard errors with the blank identifier (_). Check for errors explicitly.
panic: Reserved for truly exceptional, unrecoverable situations. Generally, libraries should not panic.