Как я завалил кучу собесов по Go и что из этого вынес

func main() {
    s := make([]int, 0, 5)
    s = append(s, 1, 2, 3)
    a := append(s, 4)
    b := append(s, 5)
    fmt.Println(a)
    fmt.Println(b)
}

type Counter struct {
    value int
}
func (c *Counter) Increment() {
    c.value++ // Чего тут сложного-то?
}

type Counter struct {
    mu    sync.Mutex
    value int
}
func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

type Counter struct {
    value int64
}
func (c *Counter) Increment() {
    atomic.AddInt64(&c.value, 1)
}

func TransferMoney(from, to int, amount decimal.Decimal) error {
    tx, err := db.Begin()
    // ... проверки ошибок
    var balance decimal.Decimal
    err = tx.QueryRow("SELECT balance FROM accounts WHERE id = ?", from).Scan(&balance)
    if balance.LessThan(amount) {
        return errors.New("денег нет, но вы держитесь")
    }
    // Списываем
    tx.Exec("UPDATE accounts SET balance = balance - ? WHERE id = ?", amount, from)
    // Зачисляем
    tx.Exec("UPDATE accounts SET balance = balance + ? WHERE id = ?", amount, to)
    return tx.Commit()
}

err = tx.QueryRow("SELECT balance FROM accounts WHERE id = ? FOR UPDATE", from).Scan(&balance)

func GetUser(userID int) (*User, error) {
    resp, err := http.Get(fmt.Sprintf("http://api/users/%d", userID))
    // дальше парсинг...
}

• Timeout control - а то запрос может висеть вечно
  
• Cancellation - если пользователь ушел, зачем тратить ресурсы?
  
• Trace propagation - для мониторинга

func GetUser(ctx context.Context, userID int) (*User, error) {
    req, err := http.NewRequestWithContext(ctx, "GET",
        fmt.Sprintf("http://api/users/%d", userID), nil)
    client := &http.Client{Timeout: 5 * time.Second}
    resp, err := client.Do(req)
    // ...
}

func ProcessData(data []string) {
    for _, item := range data {
        go func(item string) {
            result := heavyProcessing(item)
            fmt.Println(result) // И кто это будет читать?
        }(item)
    }
}

func ProcessData(data []string) error {
    var wg sync.WaitGroup
    errCh := make(chan error, len(data))
    for _, item := range data {
        wg.Add(1)
        go func(item string) {
            defer wg.Done()
            if err := heavyProcessing(item); err != nil {
                errCh <- err
            }
        }(item)
    }
    go func() {
        wg.Wait()
        close(errCh)
    }()
    for err := range errCh {
        if err != nil {
            return err
        }
    }
    return nil
}

func Process(data interface{}) interface{} {
    switch v := data.(type) {
    case string:
        return strings.ToUpper(v)
    case int:
        return v * 2
    case []interface{}:
        // тут начинается рекурсивный ад...
    default:
        return "хз что это"
    }
}

type UserRequest struct {
    Name string `json:"name"`
}
func ProcessUser(req UserRequest) (*UserResponse, error) {
    // Тут все понятно и type-safe
}

func GetUser(id int) *User {
    user, err := db.GetUser(id)
    if err != nil {
        log.Printf("Ошибка: %v", err) // "Залогировал же!"
        return nil
    }
    return user
}

func GetUser(id int) (*User, error) {
    user, err := db.GetUser(id)
    if err != nil {
        return nil, fmt.Errorf("не смог достать пользователя %d: %w", id, err)
    }
    return user, nil
}

SELECT user_id, COUNT(*)
FROM events
WHERE event_type = 'click'
  AND timestamp >= '2026-01-01'
GROUP BY user_id
ORDER BY COUNT(*) DESC

SELECT user_id, count() as clicks
FROM events
WHERE timestamp >= '2026-01-01'
  AND timestamp < '2026-02-01'  -- Используем партиции
  AND event_type = 'click'       -- После timestamp!
GROUP BY user_id
ORDER BY clicks DESC

for {
    msg, err := consumer.ReadMessage(-1)
    if err == nil {
        processMessage(msg.Value) // А если упадет?
    }
}

for {
    msg, err := consumer.ReadMessage(100 * time.Millisecond)
    if err != nil {
        continue
    }
    if err := processMessage(msg.Value); err != nil {
        log.Printf("Не смог обработать: %v", err)
        continue // НЕ коммитим offset
    }
    consumer.CommitMessage(msg) // Коммитим только тут
}

• 100 млн URL в день = ~1200 writes/sec
  
• Read:Write = 100:1 = 120,000 reads/sec
  
• Хранение за 5 лет = терабайты

• “Как обеспечить exactly-once delivery для платежей?”
  
• “Что такое идемпотентность в контексте денежных переводов?”
  
• “Как бы вы реализовали matching engine?”

• Дело не в синтаксисе Go - дело в том, как ты мыслишь как engineer
  
• Production опыт стоит больше, чем знание всех фишек языка
  
• Domain knowledge может быть решающим фактором
  
• Честность лучше чем попытка заболтать непонимание
  
• Вопросы обратно показывают, что ты думаешь о проблеме

• 60% - concurrency и как оно работает под капотом
  
• 30% - databases и distributed systems
  
• 10% - алгоритмы (и то не leetcode, а практические)

• Рассказывать про реальные проблемы которые решал
  
• Объяснять trade-offs - почему выбрал именно это решение
  
• Признавать пробелы - “не знаю, но думаю так…”
  
• Задавать вопросы - уточнять требования, обсуждать альтернативы

• Middle → Senior Go разработчики
  
• Backend engineers из других языков, переходящие на Go
  
• Финтех разработчики (особенно ценю domain expertise!)
  
• Career changers как я - никогда не поздно расти