단순 기계 번역 시 마주치는 치명적 안티패턴

• 타입 시스템 붕괴: Python의 dict를 map[string]interface{}나 any로 무분별하게 변환하여 런타임 타입 단언 패닉 초래
• 예외 처리 왜곡: Python의 try-except를 흉내 내려 panic/recover를 남용하거나 에러 리턴을 무시
• 동시성 모델 오염: asyncio.gather를 제한 없는 go func()로 변환해 메모리 OOM 및 고루틴 누수 발생
• 리소스 누수: Go의 필수적인 context.Context 생명주기 및 defer resp.Body.Close() 누락

완벽한 포팅을 위한 엔지니어링 목표

• 관용적 Go(Idiomatic Go): 정적 타입 Struct와 명시적 (T, error) 다중 반환 구조 확립
• 포인터 vs 값 리시버의 명확한 분리: 불필요한 힙 할당 방지 및 상태 뮤테이션 제어
• 구조화된 동시성(Structured Concurrency): Worker Pool, 버퍼드 채널, errgroup 적용
• 견고한 수명주기: context.Context를 통한 타임아웃 및 Graceful Cancellation 보장

❌ 레시피 A 실행 한계 분석

단순 지시 프롬프트로 생성된 코드는 공유 슬라이스(results = append(results, res))에 락 없이 무제한 고루틴으로 접근하여 데이터 레이스(Data Race) 패닉을 발생시킵니다. 또한 recover() 흉내와 무제한 HTTP 요청으로 프로덕션 서버를 즉시 다운시킵니다.

⚡ 레시피 B 실전 사례: 비동기 데이터 수집기 (Worker Pool + Context)

package scraper

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"sync"
	"time"
)

type TargetResponse struct {
	ID        int64     `json:"id"`
	Title     string    `json:"title"`
	FetchedAt time.Time `json:"fetched_at"`
}

type Scraper struct {
	client  *http.Client
	workers int
}

func NewScraper(workers int, timeout time.Duration) *Scraper {
	return &Scraper{
		workers: workers,
		client: &http.Client{
			Timeout: timeout,
			Transport: &http.Transport{
				MaxIdleConns:        100,
				MaxIdleConnsPerHost: 20,
				IdleConnTimeout:     90 * time.Second,
			},
		},
	}
}

func (s *Scraper) FetchAll(ctx context.Context, urls []string) ([]TargetResponse, []error) {
	jobs := make(chan string, len(urls))
	results := make(chan TargetResponse, len(urls))
	errs := make(chan error, len(urls))

	var wg sync.WaitGroup

	for w := 0; w < s.workers; w++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for {
				select {
				case <-ctx.Done():
					return
				case url, ok := <-jobs:
					if !ok {
						return
					}
					data, err := s.fetchOne(ctx, url)
					if err != nil {
						errs <- fmt.Errorf("fetch failed for %s: %w", url, err)
					} else {
						results <- data
					}
				}
			}
		}()
	}

	for _, u := range urls {
		jobs <- u
	}
	close(jobs)

	go func() {
		wg.Wait()
		close(results)
		close(errs)
	}()

	var finalResults []TargetResponse
	var finalErrors []error

	for res := range results {
		finalResults = append(finalResults, res)
	}
	for err := range errs {
		finalErrors = append(finalErrors, err)
	}

	return finalResults, finalErrors
}

func (s *Scraper) fetchOne(ctx context.Context, targetURL string) (TargetResponse, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, targetURL, nil)
	if err != nil {
		return TargetResponse{}, fmt.Errorf("create req: %w", err)
	}

	resp, err := s.client.Do(req)
	if err != nil {
		return TargetResponse{}, fmt.Errorf("do req: %w", err)
	}
	defer func() {
		io.Copy(io.Discard, resp.Body)
		resp.Body.Close()
	}()

	if resp.StatusCode != http.StatusOK {
		return TargetResponse{}, fmt.Errorf("unexpected status: %d", resp.StatusCode)
	}

	var data TargetResponse
	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
		return TargetResponse{}, fmt.Errorf("decode: %w", err)
	}
	data.FetchedAt = time.Now()
	return data, nil
}

🚀 레시피 C 실전 사례: 고성능 스트리밍 파이프라인 (Streaming Decoder + sync.Pool)

package pipeline

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"strings"
	"sync"

	"golang.org/x/sync/errgroup"
)

type SourceRecord struct {
	ID    string  `json:"id"`
	Value float64 `json:"value"`
}

type TransformedRecord struct {
	UID   string  `json:"uid"`
	Score float64 `json:"score"`
}

func StreamProcessJSON(ctx context.Context, r io.Reader, w io.Writer, concurrency int) error {
	dec := json.NewDecoder(r)
	token, err := dec.Token()
	if err != nil || token != json.Delim('[') {
		return fmt.Errorf("expected json array opening: %w", err)
	}

	recordChan := make(chan SourceRecord, 500)
	g, gCtx := errgroup.WithContext(ctx)
	g.SetLimit(concurrency)

	// Producer Stage
	g.Go(func() error {
		defer close(recordChan)
		for dec.More() {
			var rec SourceRecord
			if err := dec.Decode(&rec); err != nil {
				return fmt.Errorf("streaming decode: %w", err)
			}
			select {
			case <-gCtx.Done():
				return gCtx.Err()
			case recordChan <- rec:
			}
		}
		dec.Token()
		return nil
	})

	outChan := make(chan TransformedRecord, 500)
	var workerWg sync.WaitGroup

	for i := 0; i < concurrency; i++ {
		workerWg.Add(1)
		go func() {
			defer workerWg.Done()
			for item := range recordChan {
				res := TransformedRecord{
					UID:   strings.ToUpper(item.ID),
					Score: item.Value * 1.5,
				}
				select {
				case <-gCtx.Done():
					return
				case outChan <- res:
				}
			}
		}()
	}

	go func() {
		workerWg.Wait()
		close(outChan)
	}()

	enc := json.NewEncoder(w)
	for out := range outChan {
		if err := enc.Encode(out); err != nil {
			return fmt.Errorf("stream encode: %w", err)
		}
	}

	return g.Wait()
}

컴파일 및 런타임 필수 검증 명령어

• go test -race ./... : 채널 및 공유 자원 Race Condition 정밀 추적
• golangci-lint run : errcheck, contextcheck 등 정적 분석
• go test -bench=. -benchmem : 할당당 바이트(B/op)와 allocs/op 제로 할당 여부 측정