// Google의 거대한 C++ 코드베이스
// 수천만 줄의 코드
// 수십 개의 템플릿 라이브러리
// 수백 개의 헤더 파일 의존성

#include <boost/algorithm/string.hpp>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
// ... 수백 개의 include ...

template<typename T, typename U, typename V>
class SuperComplexService : public BaseService<T>,
                           public ConfigurableService<U>,
                           public LoggableService<V> {
  // 컴파일하는 데만 몇 분...
};

// 빌드 시간: 45분
// 커피 마시러 가기엔 애매하고...
// 다른 일 하기엔 너무 짧고...

// Google의 C++ 코드베이스 (2007년경)
- 수천만 줄의 C++ 코드
- 수만 개의 서비스
- 수천 명의 엔지니어
- 하루에 수만 번의 빌드

// 문제들
- 빌드 시간: 평균 30-45분
- 컴파일러 오류: 수백 줄짜리 템플릿 에러 메시지
- 의존성 관리: nightmare
- 새 엔지니어 교육: 6개월 이상

// 우리가 원하는 언어
- C의 빠른 컴파일 속도
- C++의 실행 성능
- Python의 간결함과 생산성
- Java의 타입 안전성
- 그리고 쉬운 동시성 프로그래밍

// "그런 언어는 없었다. 그래서 만들었다."

// 화이트보드에 적힌 초기 아이디어들

[ Go 설계 원칙 ]

1. 단순함 (Simplicity)
   - 배우기 쉬워야 함
   - 읽기 쉬워야 함
   - 명확해야 함

2. 빠른 컴파일
   - 의존성 관리 개선
   - 불필요한 재컴파일 제거
   - 초 단위 빌드

3. 동시성 지원
   - 언어 수준의 지원
   - 쉽고 안전해야 함
   - 멀티코어 활용

4. 타입 안전성
   - 정적 타입 시스템
   - 하지만 타입 추론으로 간결하게
   - GC로 메모리 안전성

5. 효율성
   - C에 가까운 성능
   - 작은 바이너리
   - 빠른 실행

// C/C++의 문제
#include "a.h"  // a.h가 b.h를 include
                // b.h가 c.h를 include
                // c.h가 d.h를 include...
                // 결과: 수천 개 파일이 파싱됨

// Go의 해결책
import "a"      // a만 파싱
                // a의 의존성은 컴파일러가 미리 알고 있음
                // 결과: 필요한 것만 파싱

// 고루틴: 놀라울 정도로 간단

func main() {
  // 일반 함수 호출
  doSomething()
  
  // 고루틴으로 실행 - 단 하나의 키워드 'go'
  go doSomething()
  
  // 수천 개의 고루틴도 가능
  for i := 0; i < 10000; i++ {
    go func(id int) {
      // 각각 독립적으로 실행
      fmt.Println("Goroutine", id)
    }(i)
  }
  
  time.Sleep(time.Second)
}

// 스레드가 아니라 고루틴
// 메모리: 스레드는 1-2MB, 고루틴은 2KB
// 생성 비용: 스레드는 무겁고, 고루틴은 가벼움

// 채널을 통한 통신

func main() {
  // 채널 생성
  messages := make(chan string)
  
  // 고루틴 1: 메시지 보내기
  go func() {
    messages <- "ping"  // 채널에 보내기
  }()
  
  // 고루틴 2: 메시지 받기
  msg := <-messages  // 채널에서 받기
  fmt.Println(msg)   // "ping"
}

// 스레드 + 뮤텍스 + 조건변수의 복잡함을
// 채널 하나로 해결

// Go의 동시성으로 간단한 웹 크롤러

func crawl(url string, results chan<- string) {
  resp, err := http.Get(url)
  if err != nil {
    results <- fmt.Sprintf("Error: %v", err)
    return
  }
  defer resp.Body.Close()
  
  // HTML 파싱...
  results <- fmt.Sprintf("Success: %s", url)
}

func main() {
  urls := []string{
    "https://example.com",
    "https://google.com",
    "https://github.com",
    // ... 1000개의 URL
  }
  
  results := make(chan string, len(urls))
  
  // 1000개 URL을 동시에 크롤
  for _, url := range urls {
    go crawl(url, results)
  }
  
  // 결과 수집
  for i := 0; i < len(urls); i++ {
    fmt.Println(<-results)
  }
}

// 동시성 코드가 순차 코드만큼 간단함!

func main() {
  c1 := make(chan string)
  c2 := make(chan string)
  
  go func() {
    time.Sleep(1 * time.Second)
    c1 <- "one"
  }()
  
  go func() {
    time.Sleep(2 * time.Second)
    c2 <- "two"
  }()
  
  // 두 채널 중 먼저 응답하는 것을 선택
  for i := 0; i < 2; i++ {
    select {
    case msg1 := <-c1:
      fmt.Println("Received", msg1)
    case msg2 := <-c2:
      fmt.Println("Received", msg2)
    case <-time.After(3 * time.Second):
      fmt.Println("Timeout")
    }
  }
}

// Unix의 select(), epoll의 채널 버전
// 하지만 훨씬 더 사용하기 쉬움

// Docker가 Go를 선택한 이유

// 1. 정적 바이너리
// 하나의 실행파일만 있으면 됨. 의존성 지옥 없음
$ file docker
docker: ELF 64-bit LSB executable, statically linked

// 2. 크로스 컴파일
// Mac에서 Linux 바이너리 빌드
$ GOOS=linux GOARCH=amd64 go build
// 간단!

// 3. 빠른 개발
// 빌드가 빠르니까 이터레이션이 빠름

// 4. 동시성
// 컨테이너 관리는 동시성 작업의 연속
// 고루틴이 완벽하게 맞음

// Kubernetes의 핵심 구조 (간략화)

// Controller 패턴: Go의 고루틴과 채널이 완벽하게 맞음
type Controller struct {
  queue    workqueue.Interface
  informer cache.SharedIndexInformer
}

func (c *Controller) Run(stopCh <-chan struct{}) {
  defer c.queue.ShutDown()
  
  // 워커 고루틴들 시작
  for i := 0; i < 5; i++ {
    go wait.Until(c.runWorker, time.Second, stopCh)
  }
  
  <-stopCh
}

// 수천 개의 고루틴이 동시에 돌아감
// 각 Pod, Service, Deployment마다 컨트롤러가 있음
// Go가 아니었다면 이렇게 간단할 수 없었음

// Go 커뮤니티가 선호하는 코드

// ❌ 영리한 코드 (다른 언어에서는 칭찬받을 수도)
func process(data []int) []int {
  return funk.Filter(funk.Map(data, func(x int) int {
    return x * 2
  }), func(x int) bool {
    return x > 10
  }).([]int)
}

// ✅ 단순하고 명확한 코드 (Gopher 스타일)
func process(data []int) []int {
  result := make([]int, 0, len(data))
  for _, x := range data {
    doubled := x * 2
    if doubled > 10 {
      result = append(result, doubled)
    }
  }
  return result
}

// "지루한 코드가 좋은 코드다"

# gofmt: 논쟁 종결자
$ gofmt -w .

# 탭 vs 스페이스? → gofmt가 결정
# 중괄호 위치? → gofmt가 결정
# 한 줄에 몇 글자? → gofmt가 결정

# "gofmt 스타일이 완벽하지 않을 수 있다.
#  하지만 gofmt가 있다는 것은 완벽하다."

// Go의 에러 처리 (반복적이라는 비판)

func readConfig(path string) (*Config, error) {
  file, err := os.Open(path)
  if err != nil {
    return nil, fmt.Errorf("open file: %w", err)
  }
  defer file.Close()
  
  data, err := io.ReadAll(file)
  if err != nil {
    return nil, fmt.Errorf("read file: %w", err)
  }
  
  var config Config
  err = json.Unmarshal(data, &config)
  if err != nil {
    return nil, fmt.Errorf("parse json: %w", err)
  }
  
  return &config, nil
}

// "if err != nil"이 너무 많다는 비판

// Go 1.18 이전 (2009-2022)

// 정수 슬라이스 최소값
func MinInt(slice []int) int {
  min := slice[0]
  for _, v := range slice[1:] {
    if v < min {
      min = v
    }
  }
  return min
}

// 실수 슬라이스 최소값
func MinFloat(slice []float64) float64 {
  min := slice[0]
  for _, v := range slice[1:] {
    if v < min {
      min = v
    }
  }
  return min
}

// 코드 중복! 하지만 Go는 13년간 제네릭을 거부함

// Go 1.18+ : 제네릭

// 하나의 함수로 모든 타입 지원
func Min[T constraints.Ordered](slice []T) T {
  min := slice[0]
  for _, v := range slice[1:] {
    if v < min {
      min = v
    }
  }
  return min
}

// 사용
intMin := Min([]int{3, 1, 4, 1, 5})
floatMin := Min([]float64{3.14, 1.59, 2.65})
stringMin := Min([]string{"banana", "apple", "cherry"})

// 타입 안전성 + 코드 재사용

// Go의 핵심 키워드: 단 25개
// (C++는 100개 이상)

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

package main

import "fmt"

func main() {
  fmt.Println("Hello, World!")
  
  // 단순하지만 강력함
  // 배우기 쉽지만 깊이 있음
  // 지루하지만 안정적임
  
  // 이것이 Go다
}