oops

Author: chanjunren

www/docs/zettelkasten/backend/languages/go/go_goroutines.md

@@ -0,0 +1,100 @@
+🗓️ 02112024 2312
+📎
+
+# go_goroutines
+
+**Core Concept**: Goroutines are lightweight, independently executing functions managed by the Go runtime.
+
+## Why It Matters
+
+Enable concurrent programming with minimal overhead. Thousands of goroutines can run simultaneously. Core feature of Go.
+
+## When to Use
+
+✅ **Use when:**
+- I/O-bound operations (network, file)
+- Independent tasks can run concurrently
+- Need to handle multiple requests simultaneously
+- Background processing
+
+❌ **Don't use when:**
+- Sequential operations required
+- Shared state without synchronization
+- Uncertain about race conditions
+
+## vs Java Threads
+
+| Java Threads | Go Goroutines |
+|--------------|---------------|
+| ~1MB stack | ~2KB stack (grows as needed) |
+| OS-managed | Go runtime-managed |
+| Heavy creation cost | Cheap creation |
+| Thread pools needed | Create freely |
+
+```ad-danger
+Always ensure goroutines can exit. Use [[go_context]] for cancellation to prevent goroutine leaks.
+\`\`\`
+
+## Trade-offs
+
+**Pros**: Lightweight, easy creation, efficient scheduling  
+**Cons**: Requires synchronization, race conditions possible, debugging harder
+
+Goroutines work with [[go_context]] for cancellation and channels for communication.
+
+## Quick Reference
+
+```go
+// Start goroutine with go keyword
+go doWork()
+
+// Anonymous function goroutine
+go func() {
+    fmt.Println("Running concurrently")
+}()
+
+// With parameters (evaluated immediately)
+go process(data)
+
+// Proper cancellation with context
+func worker(ctx context.Context) {
+    for {
+        select {
+        case <-ctx.Done():
+            return  // Exit when cancelled
+        default:
+            // do work
+        }
+    }
+}
+
+ctx, cancel := context.WithCancel(context.Background())
+go worker(ctx)
+// Later: cancel() to stop goroutine
+```
+
+## Common Patterns
+
+**Wait for completion:**
+```go
+var wg sync.WaitGroup
+wg.Add(1)
+go func() {
+    defer wg.Done()
+    doWork()
+}()
+wg.Wait()
+```
+
+**Fan-out (multiple workers):**
+```go
+for i := 0; i < numWorkers; i++ {
+    go worker(i, jobs, results)
+}
+```
+
+## References
+
+- [Go Tour: Goroutines](https://go.dev/tour/concurrency/1)
+- [Effective Go: Goroutines](https://go.dev/doc/effective_go#goroutines)
+

www/docs/zettelkasten/backend/languages/go/go_learning_plan.md

@@ -0,0 +1,84 @@
+🗓️ 02112024 2250
+📎
+
+# go_learning_plan
+
+**Core Concept**: Structured path for Java Spring Boot developers learning Go, focusing on mental model shifts.
+
+## Why It Matters
+
+Go requires different thinking than Java. Learning in order prevents confusion and builds solid foundations.
+
+## Learning Path
+
+### Phase 1: Mental Model Shifts (Week 1)
+**Goal**: Understand how Go differs from Java fundamentally
+
+1. [[go_error_handling]] - No exceptions, errors are values
+2. [[go_pointers]] - Explicit memory addresses, not Java references  
+3. [[go_interfaces]] - Implicit implementation (duck typing)
+4. [[go_defer]] - Resource cleanup without try-finally
+
+**Practice**: Rewrite simple Java methods in Go
+
+### Phase 2: Core Patterns (Week 2)
+**Goal**: Learn Go idioms and common patterns
+
+5. [[go_type_assertions]] - Working with interface{}
+6. [[go_context]] - Request lifecycle management
+7. [[go_dependency_injection]] - Constructor injection, no @Autowired
+
+**Next to learn**: Struct methods, goroutines, channels
+
+**Practice**: Build a simple HTTP API with clean architecture
+
+### Phase 3: Concurrency (Week 3+)
+**Goal**: Master Go's concurrency primitives
+
+- Goroutines - Lightweight threads
+- Channels - Communication between goroutines
+- Select - Multiplexing channels
+- Sync primitives - Mutexes and WaitGroups
+
+**Practice**: Build concurrent data processor
+
+### Phase 4: Production Readiness (Week 4+)
+**Goal**: Write production-grade Go code
+
+- Testing - Table-driven tests
+- Error wrapping - Error chains with %w
+- Graceful shutdown - Clean service termination
+- Project structure - Organizing real applications
+
+**Practice**: Production-ready microservice
+
+## Key Mental Shifts
+
+| Java Concept | Go Equivalent | Note |
+|--------------|---------------|------|
+| try/catch | if err != nil | Explicit |
+| @Autowired | Constructor params | Manual |
+| implements | Implicit | Duck typing |
+| synchronized | Mutexes/Channels | Explicit |
+| ThreadLocal | context.Context | Passed explicitly |
+
+## Study Tips
+
+- **Read standard library code** - Best Go examples
+- **Run `go fmt`** - Learn idiomatic style
+- **Write tests first** - Forces good design
+- **Keep functions small** - 20-30 lines max
+
+## Trade-offs
+
+**Java strengths**: Rich frameworks, strong tooling, massive ecosystem  
+**Go strengths**: Simplicity, fast compilation, built-in concurrency, single binary deployment
+
+This learning plan focuses on concepts that build on [[go_interfaces]] and [[go_error_handling]] as foundational patterns.
+
+## References
+
+- [Tour of Go](https://go.dev/tour/)
+- [Effective Go](https://go.dev/doc/effective_go)
+- [Go by Example](https://gobyexample.com/)
+

www/docs/zettelkasten/backend/languages/go/go_pass_by_value.md

@@ -0,0 +1,81 @@
+🗓️ 02112024 2310
+📎
+
+# go_pass_by_value
+
+**Core Concept**: Go always passes arguments by value - copies are made of all parameters, including pointers.
+
+## Why It Matters
+
+Explains why modifying parameters doesn't affect original values unless using pointers. Critical for understanding [[go_pointers]].
+
+## When to Use
+
+This is not a pattern to "use" - it's how Go always works. You choose whether to pass values or pointers based on whether you need mutation.
+
+## Key Distinction
+
+**Pass value:**
+```go
+func increment(x int) {
+    x = x + 1  // Modifies copy, not original
+}
+
+a := 5
+increment(a)
+fmt.Println(a)  // Still 5
+```
+
+**Pass pointer (pointer value is copied, but points to same address):**
+```go
+func increment(x *int) {
+    *x = *x + 1  // Dereferences and modifies original
+}
+
+b := 5
+increment(&b)
+fmt.Println(b)  // Now 6
+```
+
+## vs Java References
+
+| Java | Go |
+|------|-----|
+| Objects passed by reference | Everything passed by value |
+| Primitives passed by value | Pointers passed by value (address copied) |
+| No pointer syntax | Explicit `&` and `*` |
+
+## Trade-offs
+
+**Pros**: Predictable, no hidden side effects, explicit mutation  
+**Cons**: Large structs can be expensive to copy
+
+This is why [[go_pointers]] are necessary - to pass the address (by value) instead of copying large data.
+
+## Quick Reference
+
+```go
+// Value passed - copy made
+func modifyValue(s MyStruct) {
+    s.Field = "changed"  // Changes copy only
+}
+
+// Pointer passed - address copied, data accessible
+func modifyPointer(s *MyStruct) {
+    s.Field = "changed"  // Changes original
+}
+
+// Even the pointer itself is copied!
+func reassignPointer(p *int) {
+    newVal := 100
+    p = &newVal  // Only changes local copy of pointer
+}
+```
+
+**Key insight**: When you pass a pointer, the address is copied, but both the original and copy point to the same memory location.
+
+## References
+
+- [Go FAQ: Pass by Value](https://go.dev/doc/faq#pass_by_value)
+- [Effective Go: Pointers vs Values](https://go.dev/doc/effective_go#pointers_vs_values)
+