...
Pregătire interviuri

100 de întrebări de interviu pentru Backend Developer Go (cloud), cu răspunsuri

Întrebările care apar des la interviurile de Backend Developer Go (cloud), fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 51junior
  • 34mid
  • 15senior
  • 137 minde citit
Întrebări de interviu Backend Developer Go (cloud) cu răspunsuri

Procesul de interviu pentru un Backend Developer Go arată de obicei așa: o discuție inițială cu cineva din HR sau cu un recruiter, despre experiență, motivație și așteptări, apoi unul sau două interviuri tehnice. În cele tehnice se discută fundamentele limbajului (slices, maps, interfețe, erori), concurența cu goroutines și canale, construirea unui API cu net/http, lucrul cu baze de date și modul în care serviciul ajunge să ruleze în Docker și în cloud. Multe firme adaugă o temă de casă, de exemplu un mic serviciu REST cu teste, sau un exercițiu de programare live, iar la nivel mid și senior apare și o discuție de design de sistem.

La junior, intervievatorul urmărește dacă înțelegi corect bazele și le poți explica: de ce un append schimbă alt slice, cine închide un canal, cum tratezi o eroare, ce face un index. Nu se așteaptă experiență de producție, dar se apreciază proiectele proprii pe care le poți descrie în detaliu. La mid se pune accent pe cod care rezistă în producție: timeout-uri, context, tranzacții, teste, graceful shutdown. La senior, întrebările devin deschise și contează judecata: trade-off-uri, depanarea incidentelor, scalare, observabilitate și felul în care lucrezi cu echipa.

Folosește pagina activ. Citește întrebarea, încearcă să răspunzi cu voce tare, apoi compară cu răspunsul scurt și cu explicația detaliată. Rulează exemplele de cod și modifică-le, mai ales la întrebările de tip „ce afișează”. Notează întrebările la care ai ezitat și revino la ele după câteva zile. Pentru întrebările comportamentale, pregătește-ți propriile povești reale după structura din modelele de răspuns, nu le memora pe cele de aici.

Fundamentele limbajului Go

1 Junior

Ce este Go și de ce este folosit des pentru servicii backend și unelte cloud?

Răspuns scurt: Go este un limbaj compilat, cu tipuri statice și garbage collector, care produce un singur binar nativ și are concurența integrată în limbaj prin goroutines și canale. Combinația asta îl face potrivit pentru servicii de rețea și infrastructură.

Go a fost creat la Google și a apărut public în 2009, cu scopul declarat de a face simplă scrierea de software de rețea mare, întreținut de multe echipe. Câteva motive pentru care e ales la backend:

  • Binar static: go build produce un executabil fără dependențe de runtime (fără JVM sau interpretor), ușor de pus într-o imagine Docker mică.
  • Compilare rapidă, ceea ce scurtează ciclul de dezvoltare și CI-ul.
  • Concurență ieftină: o goroutine pornește cu un stack mic (câțiva KB) care crește la nevoie, deci poți avea zeci de mii de conexiuni deservite simultan.
  • Biblioteca standard bogată: net/http, encoding/json, database/sql, crypto/tls, testing acoperă mult fără framework-uri.
  • Limbaj mic: puține cuvinte cheie, un singur format de cod (gofmt), ceea ce face codul străin ușor de citit.

Multe unelte cloud cunoscute sunt scrise în Go: Docker, Kubernetes, Terraform, Prometheus. Asta înseamnă și că ecosistemul cloud are SDK-uri bune pentru Go.

Compromisurile merită spuse la interviu: tratarea erorilor e explicită și verbosă, generics au apărut abia în Go 1.18, iar limbajul evită intenționat funcționalități precum moștenirea sau excepțiile.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce ai ales tehnologia, nu doar că o folosești. Răspunsurile de tip „e rapid” fără argumente concrete (binar static, goroutines, stdlib) sună memorat.

2 Junior

Care este diferența dintre var x int și x := 0 și ce sunt zero values în Go?

Răspuns scurt: var declară o variabilă, opțional cu tip și valoare, și poate fi folosit oriunde; := declară și inițializează cu tip dedus și merge doar în interiorul funcțiilor. Orice variabilă neinițializată primește automat zero value-ul tipului ei.

Ambele forme creează o variabilă nouă, dar au reguli diferite:

  • var funcționează și la nivel de pachet, permite să dai tipul fără valoare (var count int) și e util când vrei explicit zero value.
  • := (short variable declaration) există doar în funcții, deduce tipul din expresie și cere ca măcar o variabilă din stânga să fie nouă în scope-ul curent.

Zero value înseamnă că în Go nu există memorie neinițializată: 0 pentru numere, "" pentru string, false pentru bool, nil pentru pointeri, slice-uri, map-uri, canale, funcții și interfețe, iar un struct are fiecare câmp pe zero value.

GO
var name string      // ""
var users []string   // nil, dar len(users) == 0 și append merge
var mu sync.Mutex    // gata de folosit, fără constructor
port := 8080         // int

O capcană frecventă e shadowing-ul cu := într-un bloc interior:

GO
var err error
if true {
	x, err := compute() // err nou, cel din exterior rămâne nil
	_ = x
}

Biblioteca standard e proiectată astfel încât zero value-ul să fie util („make the zero value useful”): bytes.Buffer, sync.Mutex sau strings.Builder merg fără inițializare.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi de shadowing și de regula zero value. Mulți candidați cred că o variabilă nedeclarată explicit conține „gunoi”, ca în C.

3 Junior

Ce sunt modulele Go și la ce folosesc fișierele go.mod și go.sum?

Răspuns scurt: Un modul este o colecție de pachete versionate împreună, definită de go.mod, care conține calea modulului, versiunea de Go și dependențele. go.sum reține hash-urile criptografice ale dependențelor, ca build-ul să fie verificabil și reproductibil.

De la Go 1.11 (și implicit de la 1.16) dependențele se gestionează prin modules, nu prin GOPATH. Un proiect nou începe cu:

BASH
go mod init github.com/firma/orders-service
go get github.com/jackc/pgx/v5@latest
go mod tidy

go.mod arată cam așa:

module github.com/firma/orders-service

go 1.23

require github.com/jackc/pgx/v5 v5.7.1

Directiva go contează: ea activează semantica limbajului pentru versiunea respectivă (de exemplu variabilele de buclă per iterație din Go 1.22). Dependențele urmează semantic versioning, iar pentru versiuni majore de la 2 în sus calea importului se schimbă (/v5).

go.sum nu e un lock file în sensul clasic, ci o listă de hash-uri pentru fiecare modul descărcat. La build, Go verifică hash-ul, iar implicit îl compară și cu baza publică sum.golang.org, deci un pachet modificat după publicare este detectat.

Ambele fișiere se pun în Git. go mod tidy adaugă ce lipsește și scoate ce nu mai e folosit. Pentru build-uri izolate de rețea există go mod vendor, iar pentru module private se setează GOPRIVATE.

Go folosește Minimal Version Selection: alege cea mai mică versiune care satisface toate cerințele, nu cea mai nouă disponibilă, ceea ce face build-urile previzibile.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat efectiv cu dependențe într-un proiect real. Greșeala tipică: a nu pune go.sum în Git sau a confunda directiva go cu versiunea instalată.

4 Junior

Cum controlezi vizibilitatea în Go? Ce înseamnă un identificator exportat?

Răspuns scurt: Vizibilitatea e dată de prima literă: un nume care începe cu majusculă (User, Save) e exportat și accesibil din alte pachete, iar unul cu minusculă e vizibil doar în pachetul lui. Nu există cuvinte cheie precum public sau private.

În Go unitatea de încapsulare este pachetul, nu tipul. Toate fișierele din același director cu aceeași declarație package se văd reciproc complet, inclusiv câmpurile cu literă mică.

GO
package user

type User struct {
	ID    int    // exportat
	Email string // exportat
	hash  string // vizibil doar în pachetul user
}

func New(email string) *User { return &User{Email: email} }
func validate(email string) bool { return strings.Contains(email, "@") }

Regula se aplică la tot: tipuri, funcții, metode, constante, variabile și câmpuri de struct. O consecință practică apare la JSON: encoding/json folosește reflection din alt pachet, deci ignoră câmpurile neexportate. Dacă un câmp nu apare în răspunsul API-ului, de obicei e scris cu literă mică.

Pentru granițe mai fine există directorul internal/: pachetele de sub internal pot fi importate doar de cod aflat în arborele părintelui lui internal. E modul standard de a ascunde detalii de implementare într-un serviciu sau într-o bibliotecă, fără să le expui ca API public.

Un sfat de design: exportă cât mai puțin. Tot ce e exportat devine contract pe care alții se pot baza, iar schimbarea lui strică cod din afara pachetului.

Ce urmărește intervievatorul: Verifică dacă știi că încapsularea e la nivel de pachet și de ce un câmp lipsește din JSON. Candidații veniți din Java caută adesea modificatori de acces care nu există.

5 Junior

Ce afișează codul următor și cum funcționează defer?

GO
func main() {
	for i := 0; i < 3; i++ {
		defer fmt.Println(i)
	}
	x := 10
	defer fmt.Println("x =", x)
	x = 20
}

Răspuns scurt: Afișează x = 10, apoi 2, 1, 0. Apelurile amânate cu defer rulează la ieșirea din funcție în ordine inversă (LIFO), iar argumentele lor sunt evaluate în momentul în care se execută instrucțiunea defer, nu la final.

defer programează un apel de funcție care se execută când funcția curentă se termină, fie prin return, fie printr-un panic. Sunt trei reguli de reținut:

  • Ordinea este LIFO: ultimul defer înregistrat rulează primul. De aceea x = 10 apare înaintea cifrelor, iar cifrele apar descrescător.
  • Argumentele se evaluează imediat. fmt.Println("x =", x) a copiat valoarea 10 la înregistrare, deci modificarea ulterioară în 20 nu contează.
  • Un defer poate modifica rezultatele cu nume (named results), pentru că rulează după ce return le-a setat:
GO
func f() (n int) {
	defer func() { n *= 2 }()
	return 3 // funcția întoarce 6
}

Utilizarea tipică este eliberarea resurselor imediat lângă locul unde au fost obținute:

GO
f, err := os.Open(path)
if err != nil {
	return err
}
defer f.Close()

La fel pentru mu.Unlock(), rows.Close() sau resp.Body.Close().

Capcană: defer într-o buclă lungă (de exemplu deschiderea a mii de fișiere) ține toate resursele deschise până la ieșirea din funcție. Soluția este să muți corpul buclei într-o funcție separată. Costul de performanță al lui defer a scăzut mult începând cu Go 1.14, deci nu mai e un motiv să-l eviți în cod obișnuit.

Ce urmărește intervievatorul: Este o întrebare clasică de „ce afișează”. Greșeala tipică este să crezi că se afișează x = 20 sau că ordinea e crescătoare.

6 Junior

Cum funcționează pointerii în Go și când folosești un pointer receiver în loc de value receiver?

Răspuns scurt: Un pointer reține adresa unei valori și permite modificarea ei fără copiere. Folosești pointer receiver când metoda modifică structura, când structura e mare sau conține ceva ce nu trebuie copiat (de exemplu un sync.Mutex).

În Go totul se transmite prin valoare: la apelul unei funcții se copiază argumentul. Dacă argumentul e un struct, funcția primește o copie; dacă e un pointer, primește o copie a adresei și poate modifica originalul.

GO
type Account struct{ Balance int }

func (a Account) Show() int     { return a.Balance } // value receiver
func (a *Account) Deposit(n int) { a.Balance += n }  // pointer receiver

acc := Account{}
acc.Deposit(100) // Go ia automat &acc
fmt.Println(acc.Show()) // 100

Dacă Deposit ar avea value receiver, ar modifica o copie, iar Balance ar rămâne 0. E una dintre cele mai frecvente erori la început.

Când alegi pointer receiver:

  • metoda modifică starea;
  • struct-ul e mare și copierea lui la fiecare apel costă;
  • struct-ul conține sync.Mutex sau alte câmpuri care nu au voie să fie copiate (go vet avertizează);
  • vrei consistență: dacă o metodă are pointer receiver, de obicei toate îl au.

Value receiver e potrivit pentru tipuri mici și imuabile, precum time.Time.

Go nu are aritmetică de pointeri (în afară de pachetul unsafe), iar new(T) sau &T{} alocă și întorc un pointer. E sigur să întorci adresa unei variabile locale: compilatorul o mută pe heap dacă e nevoie (escape analysis). Atenție la dereferențierea unui pointer nil, care produce panic.

Ce urmărește intervievatorul: Verifică înțelegerea transmiterii prin valoare. Mulți candidați nu pot explica de ce modificarea din metodă „nu se vede” când receiver-ul e valoare.

7 Junior

Ce sunt constantele în Go și cum folosești iota?

Răspuns scurt: Constantele sunt valori cunoscute la compilare (numere, string-uri, bool), declarate cu const. iota este un contor care începe de la 0 în fiecare bloc const și crește cu 1 pe fiecare linie, util pentru enumerări.

Go nu are un tip enum dedicat, așa că enumerările se fac cu un tip propriu plus constante:

GO
type Status int

const (
	StatusPending Status = iota // 0
	StatusPaid                  // 1
	StatusShipped               // 2
	StatusCancelled             // 3
)

func (s Status) String() string {
	switch s {
	case StatusPending:
		return "pending"
	case StatusPaid:
		return "paid"
	case StatusShipped:
		return "shipped"
	case StatusCancelled:
		return "cancelled"
	}
	return "unknown"
}

Metoda String() face ca fmt.Println(s) să afișeze numele, nu cifra. Unealta stringer poate genera automat această metodă prin go generate.

iota se poate folosi în expresii, de exemplu pentru flag-uri pe biți sau unități:

GO
const (
	_  = iota
	KB = 1 << (10 * iota) // 1024
	MB                    // 1048576
)

Constantele numerice fără tip explicit („untyped constants”) au precizie arbitrară la compilare și primesc un tip abia când sunt folosite, de aceea time.Second * 5 merge fără conversie.

Un sfat practic: dacă valoarea zero nu are sens de business, lasă iota 0 pentru „unknown” sau pornește de la 1. Astfel un câmp neinițializat nu e confundat cu o stare validă. Și reține că o constantă de tip Status nu împiedică pe cineva să scrie Status(42), deci validează valorile venite din exterior.

Ce urmărește intervievatorul: Se urmărește dacă știi cum se modelează enumerări fără enum. Greșeala comună: a lăsa valoarea 0 să însemne o stare reală, care apare apoi din câmpuri neinițializate.

8 Junior

Cum întorci mai multe valori dintr-o funcție și ce sunt named return values?

Răspuns scurt: O funcție Go poate întoarce mai multe valori, de obicei rezultatul plus o eroare: func find(id int) (User, error). Named results dau nume valorilor întoarse, care devin variabile locale inițializate cu zero value.

Valorile multiple sunt baza tratării erorilor în Go. Convenția este ca eroarea să fie ultima valoare:

GO
func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("împărțire la zero")
	}
	return a / b, nil
}

q, err := divide(10, 2)
if err != nil {
	log.Fatal(err)
}
_, err = divide(1, 0) // ignori explicit prima valoare cu _

Același mecanism apare în limbaj: v, ok := m[key], v, ok := x.(T), v, ok := <-ch.

Named results:

GO
func parse(s string) (n int, err error) {
	n, err = strconv.Atoi(s)
	if err != nil {
		err = fmt.Errorf("parse %q: %w", s, err)
	}
	return // „naked return”
}

Sunt utile în două situații: ca documentație când două valori au același tip ((lat, lng float64)) și când un defer trebuie să modifice rezultatul, de exemplu să atașeze eroarea de la Close().

Ce să eviți: naked return în funcții lungi, unde cititorul nu mai știe ce se întoarce, și shadowing-ul accidental al unui named result cu := într-un bloc interior. Majoritatea ghidurilor de stil recomandă return explicit în afara funcțiilor foarte scurte.

Ce urmărește intervievatorul: Verifică familiaritatea cu idiomul (valoare, error). Un semnal rău este folosirea naked return peste tot sau ignorarea erorilor cu _ fără motiv.

9 Junior

Ce afișează acest cod și ce este un closure?

GO
func counter() func() int {
	c := 0
	return func() int {
		c++
		return c
	}
}

func main() {
	a := counter()
	b := counter()
	fmt.Println(a(), a(), b())
}

Răspuns scurt: Afișează 1 2 1. Fiecare apel al lui counter() creează o variabilă c nouă, iar funcția întoarsă este un closure care păstrează referința la propria c între apeluri; a și b au contoare independente.

Un closure este o funcție anonimă care folosește variabile din scope-ul în care a fost definită. Variabila capturată trăiește cât timp trăiește closure-ul, chiar dacă funcția exterioară s-a terminat. Compilatorul o mută pe heap prin escape analysis.

În exemplu:

  • a := counter() creează c₁ = 0 și o funcție legată de ea;
  • b := counter() creează un c₂ = 0 separat;
  • a() → 1, a() → 2, b() → 1.

Argumentele lui fmt.Println se evaluează de la stânga la dreapta, deci rezultatul e 1 2 1.

Unde întâlnești closure-uri în backend:

  • middleware HTTP, care întoarce un handler ce „ține minte” dependențe:
GO
func withLogger(l *slog.Logger, next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		l.Info("request", "path", r.URL.Path)
		next.ServeHTTP(w, r)
	})
}
  • funcții de configurare (functional options), sort.Slice cu funcția de comparare, defer func() { ... }().

Atenție: un closure capturează variabila, nu valoarea de la acel moment. Dacă variabila se modifică ulterior, closure-ul vede valoarea nouă. Iar dacă mai multe goroutines apelează același closure care modifică c, ai un data race și trebuie sincronizare (mutex sau atomic).

Ce urmărește intervievatorul: Testează dacă înțelegi capturarea variabilelor și stare izolată per instanță. Greșeala tipică: a crede că a și b împart contorul.

10 Mid

Ce afișează codul de mai jos, în funcție de versiunea de Go?

GO
var funcs []func()
for i := 0; i < 3; i++ {
	funcs = append(funcs, func() { fmt.Println(i) })
}
for _, f := range funcs {
	f()
}

Răspuns scurt: Începând cu Go 1.22 (cu go 1.22 sau mai nou în go.mod) afișează 0 1 2, pentru că fiecare iterație are propria variabilă i. În versiunile mai vechi afișa 3 3 3, pentru că toate closure-urile capturau aceeași variabilă.

Un closure nu copiază valoarea, ci capturează variabila. Până la Go 1.21, o buclă for avea o singură variabilă i pentru toate iterațiile, deci toate funcțiile vedeau valoarea finală, 3. Bug-ul era și mai periculos cu goroutines:

GO
for _, job := range jobs {
	go func() {
		process(job) // înainte de 1.22: adesea același job de mai multe ori
	}()
}

Go 1.22 a schimbat semantica: în buclele for cu := și în for range, fiecare iterație primește o variabilă nouă. Schimbarea depinde de directiva go din go.mod, nu doar de compilatorul instalat, ca să nu strice cod vechi. Deci un modul cu go 1.21 compilat cu Go 1.23 păstrează comportamentul vechi.

În codul vechi vei vedea două soluții standard, încă valide:

GO
for i := 0; i < 3; i++ {
	i := i // copie locală per iterație
	funcs = append(funcs, func() { fmt.Println(i) })
}

for _, job := range jobs {
	go func(j Job) { process(j) }(job) // transmis ca argument
}

go vet avea un analizor (loopclosure) pentru cazul cu goroutines. La interviu e bine să menționezi ambele comportamente: vei lucra adesea pe proiecte care încă au o versiune veche în go.mod.

Ce urmărește intervievatorul: Testează înțelegerea closure-urilor și atenția la versiuni. Un candidat bun spune „depinde de directiva go din go.mod” și explică de ce.

11 Mid

Ce sunt panic și recover și când este acceptabil să le folosești?

Răspuns scurt: panic oprește execuția normală, rulează funcțiile amânate și, dacă nu e prins, termină programul. recover, apelat într-un defer, oprește panica. Le folosești pentru erori de programare imposibile sau ca plasă de siguranță la granița unui serviciu, nu pentru fluxul normal.

În Go, erorile așteptate (fișier lipsă, input invalid, timeout) se întorc ca valori error. panic e pentru situații în care programul e într-o stare greșită: index în afara slice-ului, dereferențiere de nil, o invariantă încălcată.

Când apare un panic, Go derulează stack-ul goroutinei curente și execută fiecare defer. recover() întoarce valoarea panicii doar dacă e apelat direct într-o funcție amânată:

GO
func safeHandler(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if v := recover(); v != nil {
				slog.Error("panic", "value", v, "stack", string(debug.Stack()))
				http.Error(w, "internal error", http.StatusInternalServerError)
			}
		}()
		next.ServeHTTP(w, r)
	})
}

De reținut:

  • recover prinde doar panica din aceeași goroutine. Un panic într-o goroutine pornită din handler omoară tot procesul, chiar dacă handler-ul are recover. Fiecare goroutine de lungă durată are nevoie de propria protecție.
  • net/http are deja un recover per conexiune și loghează panica, dar un middleware propriu îți dă control asupra logării și răspunsului.
  • Funcțiile Must... (regexp.MustCompile, template.Must) folosesc panic la inițializare, unde o eroare înseamnă bug în cod.
  • Unele erori de runtime nu pot fi prinse deloc, de exemplu fatal error: concurrent map writes.

Nu folosi panic/recover ca try/catch pentru a sări peste niveluri de cod.

Ce urmărește intervievatorul: Verifică dacă faci diferența între erori așteptate și bug-uri. Semnal bun: știi că recover nu traversează goroutines.

12 Mid

În ce ordine se inițializează un program Go și ce rol are funcția init()?

Răspuns scurt: Mai întâi se inițializează pachetele importate, recursiv, apoi variabilele de nivel de pachet în ordinea dependențelor, apoi funcțiile init() ale pachetului, iar la final rulează main(). Fiecare pachet se inițializează o singură dată.

Ordinea concretă:

  • Pachetele dependente se inițializează înaintea celor care le importă. Dacă main importă db și db importă config, ordinea e config, db, main.
  • În fiecare pachet, variabilele de nivel de pachet se inițializează în ordinea dependențelor dintre ele, nu neapărat în ordinea din fișier.
  • Apoi rulează toate funcțiile init() ale pachetului. Pot exista mai multe, chiar și mai multe în același fișier. Ordinea între fișiere este cea în care fișierele sunt date compilatorului (unealta go le sortează după nume), deci e bine să nu depinzi de ea.
  • La final, main.main().

init() nu poate fi apelată explicit și nu primește argumente. Un caz legitim des întâlnit este importul pentru efecte secundare:

GO
import (
	"database/sql"
	_ "github.com/jackc/pgx/v5/stdlib" // init() înregistrează driverul "pgx"
)

db, err := sql.Open("pgx", dsn)

La fel funcționează _ "net/http/pprof", care înregistrează rutele de profilare.

De ce init() e privită cu prudență în servicii:

  • ascunde logică ce rulează la import, greu de testat;
  • nu poate întoarce erori, deci singura opțiune la eșec e panic;
  • citirea configurării sau conectarea la baza de date în init() face testele lente și dependente de mediu.

Recomandarea curentă: inițializare explicită în main(), cu dependențe transmise prin constructori (NewServer(db, logger)).

Ce urmărește intervievatorul: Se verifică înțelegerea ciclului de viață al programului și a importului cu _. Candidații care pun conexiunea la DB în init() ridică un semnal de alarmă.

13 Mid

Ce sunt generics în Go, de la ce versiune există și când merită să le folosești?

Răspuns scurt: Generics au apărut în Go 1.18 și permit funcții și tipuri cu parametri de tip, restrânși prin constraints (interfețe). Merită când scrii același algoritm pentru mai multe tipuri, de exemplu colecții sau utilitare; pentru comportament polimorfic rămân mai potrivite interfețele obișnuite.

Un parametru de tip se declară între paranteze drepte, iar constraint-ul spune ce operații sunt permise:

GO
type Number interface {
	~int | ~int64 | ~float64
}

func Sum[T Number](xs []T) T {
	var total T
	for _, x := range xs {
		total += x
	}
	return total
}

fmt.Println(Sum([]int{1, 2, 3}))     // 6
fmt.Println(Sum([]float64{1.5, 2})) // 3.5

~int înseamnă „orice tip al cărui tip de bază e int”, deci merge și pentru type Celsius int. Constraint-uri predefinite: any și comparable (tipuri care suportă ==, necesar pentru chei de map). Pachetul cmp (Go 1.21) oferă cmp.Ordered.

Și tipurile pot fi generice:

GO
type Set[T comparable] map[T]struct{}

func (s Set[T]) Add(v T) { s[v] = struct{}{} }

Biblioteca standard folosește generics în slices și maps (Go 1.21): slices.Contains, slices.SortFunc, maps.Clone.

Când nu le folosești: dacă o funcție doar apelează o metodă pe argument, o interfață simplă (io.Writer) e mai clară. Ghidul oficial spune, pe scurt, să scrii întâi cod concret și să introduci generics când vezi duplicare reală. Limitări de știut: metodele nu pot avea parametri de tip proprii, iar constraint-urile cu uniuni de tipuri nu pot fi folosite ca tipuri obișnuite de variabile.

Ce urmărește intervievatorul: Verifică dacă ții pasul cu limbajul și dacă ai judecată în a nu complica codul. Greșeala tipică: generics peste tot, unde o interfață ar fi suficientă.

14 Senior

Explică escape analysis și cum funcționează garbage collector-ul în Go. Cum ai reduce presiunea pe GC într-un serviciu?

Răspuns scurt: Compilatorul decide prin escape analysis dacă o valoare poate sta pe stack sau trebuie mutată pe heap. GC-ul Go este concurent, de tip mark-and-sweep, cu pauze scurte, și se reglează cu GOGC și GOMEMLIMIT. Reduci presiunea alocând mai puțin pe heap.

Escape analysis rulează la compilare. O valoare rămâne pe stack (eliberată gratuit la ieșirea din funcție) dacă nu supraviețuiește funcției. „Scapă” pe heap când, de exemplu, întorci un pointer la ea, o stochezi într-o interfață, o capturezi într-un closure care trăiește mai mult sau compilatorul nu îi știe mărimea. Poți vedea deciziile:

BASH
go build -gcflags='-m' ./...
# ./user.go:12:9: &User{...} escapes to heap

Garbage collector-ul e un tri-color mark-and-sweep concurent: marchează obiectele accesibile în paralel cu programul, folosind write barriers, și are doar pauze stop-the-world scurte. Nu e generațional și nu mută obiectele. Reglaje:

  • GOGC (implicit 100): GC pornește când heap-ul crește cu 100% față de heap-ul viu de după ultimul ciclu. Valoare mai mare înseamnă mai puțin CPU pe GC și mai multă memorie.
  • GOMEMLIMIT (Go 1.19+): o limită soft de memorie, utilă în containere, ca GC-ul să lucreze mai agresiv înainte de OOM kill.

Cum reduci alocările, după ce ai măsurat cu pprof (profilul allocs) și benchmark-uri cu -benchmem:

  • prealoci slice-uri și map-uri când știi mărimea (make([]T, 0, n));
  • refolosești buffere cu sync.Pool pentru obiecte temporare des alocate;
  • eviți conversiile repetate string ↔ []byte și concatenarea în bucle (strings.Builder);
  • folosești valori în loc de pointeri pentru struct-uri mici;
  • eviți boxing-ul în any pe căile fierbinți.

Optimizează doar unde profilul arată o problemă reală.

Ce urmărește intervievatorul: Diferențiază seniorii care au optimizat servicii reale de cei care repetă teorie. Semnal bun: „întâi măsor cu pprof”, plus cunoașterea lui GOMEMLIMIT în containere.

Slices, maps, structuri și interfețe

15 Junior

Care este diferența dintre un array și un slice în Go?

Răspuns scurt: Un array are lungimea fixă, parte din tip ([3]int diferă de [4]int), și se copiază integral la atribuire. Un slice este o vedere dinamică peste un array: are pointer, lungime și capacitate, iar copierea lui copiază doar acest antet.

Array-ul este o valoare: var a [3]int ocupă exact trei int-uri, iar b := a copiază toate elementele. Lungimea face parte din tip, deci o funcție care primește [3]int nu acceptă [4]int. De aceea array-urile apar rar direct în cod; le vezi la chei fixe, de exemplu [32]byte pentru un hash SHA-256.

Slice-ul este tipul folosit aproape mereu:

GO
s := []int{1, 2, 3}          // literal
s2 := make([]int, 0, 10)     // len 0, cap 10
arr := [5]int{1, 2, 3, 4, 5}
part := arr[1:4]             // [2 3 4], len 3, cap 4

part[0] = 99
fmt.Println(arr) // [1 99 3 4 5]

Exemplul arată ideea centrală: slice-ul nu deține datele, ci indică spre un array de bază (backing array). Mai multe slice-uri pot împărți același array, deci o modificare printr-unul se vede prin celelalte.

Diferențe practice:

  • un slice poate fi nil (zero value), cu len 0; append funcționează pe el;
  • slice-urile nu se pot compara cu == decât cu nil (folosește slices.Equal, Go 1.21+);
  • transmiterea unui slice către o funcție e ieftină și permite funcției să modifice elementele, dar nu și lungimea văzută de apelant, dacă nu întoarce slice-ul nou.

De aceea idiomul este s = append(s, x): rezultatul lui append trebuie mereu reatribuit.

Ce urmărește intervievatorul: E o întrebare de bază care filtrează rapid. Intervievatorul vrea să audă cuvintele „backing array”, „len” și „cap”, nu doar „slice-ul e dinamic”.

16 Junior

Ce afișează codul următor și de ce?

GO
a := []int{1, 2, 3}
b := a[:2]
b = append(b, 99)
fmt.Println(a, b)

Răspuns scurt: Afișează [1 2 99] [1 2 99]. b are lungimea 2 dar capacitatea 3, deci append are loc în array-ul comun și suprascrie a[2]. Abia când capacitatea se termină, append alocă un array nou și slice-urile se despart.

a[:2] creează un slice care pornește de la același array de bază ca a, cu len = 2 și cap = 3. Când apelezi append(b, 99):

  • dacă len < cap, elementul se scrie în array-ul existent, la poziția len, și se întoarce un slice cu lungimea mărită;
  • dacă len == cap, se alocă un array nou, mai mare, se copiază elementele, iar slice-ul întors indică spre noul array.

Aici e primul caz, deci a[2] devine 99. Continuăm exemplul:

GO
b = append(b, 100) // cap epuizată, array nou
b[0] = -1
fmt.Println(a, b) // [1 2 99] [-1 2 99 100]

Acum a și b nu mai au nimic în comun.

Strategia exactă de creștere a capacității este un detaliu de implementare (aproximativ dublare pentru slice-uri mici, apoi creștere mai lentă), așa că nu scrie cod care depinde de ea.

Cum eviți surprizele:

  • când vrei o copie independentă: c := slices.Clone(a) (Go 1.21) sau c := append([]int(nil), a...);
  • când dai un sub-slice altcuiva și nu vrei ca append să-ți strice datele, limitează capacitatea cu expresia cu trei indici: b := a[:2:2];
  • reatribuie mereu rezultatul: s = append(s, x).

Acest comportament provoacă bug-uri reale când o funcție primește un slice, face append și apelantul vede valori modificate neașteptat.

Ce urmărește intervievatorul: Testează modelul mental despre backing array și capacitate. Greșeala tipică este răspunsul [1 2 3] [1 2 99].

17 Junior

Cum lucrezi cu map-uri în Go? Cum verifici dacă o cheie există și ce se întâmplă dacă scrii într-un map nil?

Răspuns scurt: Un map se creează cu make(map[K]V) sau cu un literal. Citirea unei chei lipsă întoarce zero value, deci existența se verifică cu forma v, ok := m[k]. Citirea dintr-un map nil merge, dar scrierea în el produce panic.

Operațiile de bază:

GO
stock := map[string]int{"mere": 10}
stock["pere"] = 5        // inserare sau actualizare
delete(stock, "mere")    // ștergere; fără eroare dacă lipsește
n := len(stock)

qty, ok := stock["prune"]
if !ok {
	fmt.Println("nu avem prune") // qty este 0
}

Forma „comma ok” e necesară pentru că stock["prune"] întoarce 0 și când cheia lipsește, și când valoarea chiar e 0. Fără ok nu poți distinge cele două cazuri.

Map-ul nil:

GO
var m map[string]int
fmt.Println(m["x"]) // 0, merge
m["x"] = 1          // panic: assignment to entry in nil map

Apare des la un câmp de tip map într-un struct neinițializat. Soluția este un constructor care face make, sau inițializare leneșă înainte de prima scriere.

Alte reguli:

  • cheile trebuie să fie de tip comparabil (string, numere, pointeri, struct-uri cu câmpuri comparabile), nu slice-uri, map-uri sau funcții;
  • un map e un tip referință: transmis unei funcții, modificările se văd la apelant;
  • pentru un set se folosește map[string]struct{}, pentru că struct{} ocupă 0 bytes;
  • clear(m) (Go 1.21) golește map-ul;
  • map-urile nu sunt sigure pentru scrieri concurente; ai nevoie de un mutex sau de sync.Map.

Ce urmărește intervievatorul: Verifică idiomul comma ok și cunoașterea panicii pe map nil, ambele surse comune de bug-uri în producție.

18 Junior

În ce ordine sunt parcurse cheile unui map cu range? Cum obții o ordine stabilă?

Răspuns scurt: Ordinea de iterație într-un map nu este specificată, iar runtime-ul Go o randomizează intenționat, deci poate diferi de la o rulare la alta. Pentru ordine stabilă extragi cheile, le sortezi și parcurgi map-ul după ele.

Specificația limbajului spune explicit că ordinea de iterație nu e garantată. Implementarea alege un punct de pornire aleator la fiecare range, tocmai ca programatorii să nu depindă de o ordine accidentală care s-ar putea schimba între versiuni.

Unde apare problema în practică: teste care compară un output construit dintr-un map, răspunsuri JSON construite manual, loguri care par „să sară”, sau generarea unei semnături pe parametri.

Soluția clasică:

GO
prices := map[string]int{"b": 2, "a": 1, "c": 3}

keys := make([]string, 0, len(prices))
for k := range prices {
	keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
	fmt.Println(k, prices[k])
}

Din Go 1.23, cu iteratoare, se poate scrie mai scurt:

GO
for _, k := range slices.Sorted(maps.Keys(prices)) {
	fmt.Println(k, prices[k])
}

Un detaliu util: encoding/json sortează cheile map-urilor la serializare, deci json.Marshal pe un map[string]int produce output determinist. Iar fmt.Println(m) afișează map-urile cu cheile sortate (din Go 1.12), ceea ce poate crea impresia greșită că map-ul în sine e ordonat.

Dacă ai nevoie permanent de ordine (de exemplu ordinea inserării), folosește un slice de perechi sau o structură care combină slice și map.

Ce urmărește intervievatorul: Testează dacă știi că ordinea nu e garantată și dacă ai scris vreodată teste deterministe. Greșeala tipică: „sunt în ordinea inserării”.

19 Junior

Cum funcționează struct-urile și embedding-ul în Go? Are Go moștenire?

Răspuns scurt: Go nu are moștenire de clase. Folosește struct-uri și compoziție: prin embedding incluzi un tip în altul fără nume de câmp, iar câmpurile și metodele lui sunt „promovate” și accesibile direct. Este tot compoziție, nu o relație de tip „este un”.

Un struct grupează câmpuri:

GO
type Address struct {
	City, Street string
}

type Customer struct {
	ID      int
	Name    string
	Address // embedded
}

func (a Address) Full() string { return a.Street + ", " + a.City }

c := Customer{ID: 1, Name: "Ana", Address: Address{City: "Cluj", Street: "Memorandumului 1"}}
fmt.Println(c.City)   // câmp promovat
fmt.Println(c.Full()) // metodă promovată

c.City e doar o prescurtare pentru c.Address.City. Diferența față de moștenire:

  • Customer nu este un Address; nu poți da un Customer unei funcții care cere Address;
  • metoda promovată primește ca receiver Address, nu Customer, deci nu există „override” cu dispatch dinamic;
  • dacă Customer definește propria metodă Full(), aceasta o ascunde pe cea promovată, dar codul din Address va apela tot versiunea lui.

Totuși, metodele promovate contează pentru interfețe: dacă Address implementează fmt.Stringer, și Customer o implementează.

Embedding-ul e folosit des pentru:

  • a include un sync.Mutex într-un struct (atenție, metodele Lock/Unlock devin publice dacă tipul e exportat);
  • a compune interfețe: type ReadWriter interface { Reader; Writer };
  • a „decora” un tip existent, suprascriind doar o metodă (de exemplu un http.ResponseWriter care reține status code-ul).

Ce urmărește intervievatorul: Verifică dacă ai trecut de la gândirea OOP clasică la compoziție. Candidații care descriu embedding-ul ca moștenire greșesc la întrebări despre override.

20 Junior

Cum se implementează o interfață în Go? Ce înseamnă că implementarea este implicită?

Răspuns scurt: O interfață este un set de metode. Un tip o implementează automat dacă are toate metodele ei, fără cuvântul implements. Asta permite să definești interfața acolo unde e folosită, nu acolo unde e implementat tipul.

Exemplu:

GO
type Notifier interface {
	Notify(ctx context.Context, to, msg string) error
}

type EmailNotifier struct{ host string }

func (e EmailNotifier) Notify(ctx context.Context, to, msg string) error {
	// trimite e-mail
	return nil
}

func Remind(n Notifier, user string) error {
	return n.Notify(context.Background(), user, "Ai o comandă în așteptare")
}

EmailNotifier nu menționează nicăieri Notifier, dar poate fi transmis lui Remind. Verificarea se face la compilare, deci nu e duck typing dinamic ca în Python, ci structural typing static.

Avantaje concrete:

  • decuplare: pachetul care consumă definește o interfață mică cu exact ce îi trebuie, iar tipurile din alte pachete (chiar și din biblioteci externe) o satisfac fără să știe de ea;
  • testare: în teste dai un fake care implementează aceeași metodă;
  • interfețe standard mici și foarte refolosite: io.Reader, io.Writer, fmt.Stringer, error.

Dezavantajul: nu e evident ce interfețe implementează un tip. Dacă vrei garanție la compilare, există un idiom:

GO
var _ Notifier = EmailNotifier{}

Linia nu face nimic la rulare, dar compilarea eșuează dacă EmailNotifier pierde metoda.

O valoare de tip interfață reține intern două lucruri: tipul concret și valoarea. Asta explică mai multe capcane, de exemplu diferența dintre o interfață nil și una care conține un pointer nil.

Ce urmărește intervievatorul: Este întrebarea centrală despre designul în Go. Intervievatorul vrea să audă „implicit”, „definită la consumator” și utilitatea la testare.

21 Junior

Ce este any (interfața goală) și cum extragi tipul concret cu type assertion și type switch?

Răspuns scurt: any este alias pentru interface{} (din Go 1.18) și poate conține orice valoare. Obții tipul concret cu type assertion, v, ok := x.(string), sau cu un type switch care tratează mai multe tipuri posibile.

Interfața goală nu are metode, deci orice tip o satisface. O vezi la fmt.Println(a ...any), la decodarea JSON în map[string]any sau la context values.

Type assertion:

GO
var x any = "salut"

s := x.(string)       // ok, s = "salut"
n, ok := x.(int)      // ok = false, n = 0, fără panic
m := x.(int)          // panic: interface conversion

Folosește mereu forma cu ok când nu ești sigur de tip.

Type switch:

GO
func describe(v any) string {
	switch t := v.(type) {
	case nil:
		return "nimic"
	case int:
		return fmt.Sprintf("int %d", t)
	case string:
		return "string de lungime " + strconv.Itoa(len(t))
	case error:
		return "eroare: " + t.Error()
	default:
		return fmt.Sprintf("tip necunoscut %T", t)
	}
}

În fiecare case, t are tipul respectiv. Un case poate fi și o interfață, ca error mai sus.

Un detaliu des întâlnit: după json.Unmarshal într-un map[string]any, numerele devin float64, nu int. Un v.(int) va eșua, ceea ce e o sursă frecventă de bug-uri.

Recomandarea generală: any înseamnă că pierzi verificarea tipurilor la compilare. În codul tău de business preferă tipuri concrete, interfețe cu metode sau generics; lasă any pentru granițe reale (serializare, logare).

Ce urmărește intervievatorul: Verifică dacă știi să lucrezi sigur cu valori dinamice. Semnalul rău: type assertion fără ok pe date venite din exterior.

22 Junior

Ce diferență este între string, []byte și rune? Cât este len("ță")?

Răspuns scurt: Un string este o secvență imuabilă de bytes, de obicei UTF-8; []byte este aceeași idee, dar mutabilă; rune este un alias pentru int32 și reprezintă un code point Unicode. len("ță") este 4, pentru că len numără bytes, iar fiecare literă are 2 bytes în UTF-8.

În Go, sursele sunt UTF-8, iar string reține bytes, nu „caractere”. Caracterele românești ă, â, î, ș, ț ocupă câte 2 bytes, deci:

GO
s := "ță"
fmt.Println(len(s))                    // 4
fmt.Println(utf8.RuneCountInString(s)) // 2
fmt.Println(s[0])                      // 200, primul byte, nu „ț”

for i, r := range s {
	fmt.Println(i, string(r)) // 0 ț, apoi 2 ă
}

range pe un string decodează UTF-8 și întoarce indexul de byte și rune-ul. Indexarea directă s[i] întoarce un byte. Tăierea s[:1] poate produce un string invalid, cu un caracter rupt, iar asta apare în bug-uri reale de trunchiere a textului pentru UI sau SMS.

Imuabilitatea: nu poți scrie s[0] = 'x'. Conversia []byte(s) sau string(b) copiază de regulă datele, ceea ce costă în bucle fierbinți.

Pentru construirea de string-uri:

GO
var b strings.Builder
for _, name := range names {
	b.WriteString(name)
	b.WriteByte(',')
}
result := b.String()

Concatenarea cu += într-o buclă creează un string nou la fiecare pas.

Când alegi ce: string pentru text și chei de map, []byte pentru I/O (io.Reader lucrează cu bytes, json.Marshal întoarce []byte), []rune când chiar ai nevoie să manipulezi caractere individuale.

Ce urmărește intervievatorul: Verifică înțelegerea UTF-8, relevantă pentru aplicații cu text în română. Greșeala tipică: len folosit ca număr de caractere.

23 Junior

Cum controlezi serializarea JSON a unui struct? La ce folosesc struct tags precum json:"name,omitempty"?

Răspuns scurt: Struct tags sunt metadate atașate câmpurilor, citite prin reflection. encoding/json folosește tag-ul json pentru numele cheii, omitempty pentru a omite valorile goale și - pentru a ignora câmpul. Doar câmpurile exportate sunt serializate.

Exemplu tipic pentru un API:

GO
type User struct {
	ID        int64     `json:"id"`
	Email     string    `json:"email"`
	Password  string    `json:"-"`
	Nickname  string    `json:"nickname,omitempty"`
	CreatedAt time.Time `json:"created_at"`
	internal  string    // ignorat, neexportat
}

b, _ := json.Marshal(User{ID: 1, Email: "ana@exemplu.ro"})
// {"id":1,"email":"ana@exemplu.ro","created_at":"0001-01-01T00:00:00Z"}

Ce se întâmplă:

  • json:"-" exclude complet parola din răspuns, important pentru securitate;
  • omitempty omite valorile zero: "", 0, false, nil, slice sau map gol. Nu omite un struct gol, de aceea CreatedAt apare cu data zero. Pentru câmpuri de tip struct se folosește un pointer, iar din Go 1.24 există și opțiunea omitzero;
  • time.Time se serializează în format RFC 3339.

La decodare (json.Unmarshal sau json.NewDecoder(r.Body).Decode(&u)), potrivirea cheilor cu câmpurile nu ține cont de majuscule, iar cheile necunoscute sunt ignorate. Poți fi strict cu dec.DisallowUnknownFields().

Când e nevoie să distingi „câmp lipsă” de „câmp cu valoarea zero” (de exemplu la un PATCH), folosește pointeri: Age *int. nil înseamnă că nu a fost trimis.

Struct tags se folosesc și de alte biblioteci: db:"..." pentru mapare SQL, validate:"required" pentru validare, yaml:"...". Sunt simple string-uri, deci o greșeală de scriere nu dă eroare la compilare; go vet verifică forma lor.

Ce urmărește intervievatorul: Este muncă zilnică pe backend. Se verifică dacă știi să nu expui date sensibile și dacă înțelegi limitele lui omitempty.

24 Mid

Ce afișează codul următor și de ce?

GO
type MyErr struct{}

func (*MyErr) Error() string { return "boom" }

func run() error {
	var e *MyErr = nil
	return e
}

func main() {
	fmt.Println(run() == nil)
}

Răspuns scurt: Afișează false. Valoarea de tip interfață întoarsă conține tipul *MyErr și un pointer nil. O interfață este nil doar când atât tipul, cât și valoarea sunt nule, deci comparația cu nil eșuează.

O valoare de tip interfață are două componente: tipul dinamic și valoarea dinamică. Când scrii return e, Go convertește *MyErr la error și creează perechea (tip = *MyErr, valoare = nil). Comparația err == nil verifică dacă perechea e (nil, nil), deci rezultatul e false.

Consecința în producție e urâtă: apelantul vede err != nil, loghează sau întoarce eroare, deși „nu s-a întâmplat nimic”. Sau apelează err.Error() și metoda e executată pe un receiver nil.

Varianta corectă este să întorci explicit nil de tip interfață:

GO
func run() error {
	var e *MyErr
	if somethingFailed() {
		e = &MyErr{}
	}
	if e == nil {
		return nil
	}
	return e
}

Regula generală: funcțiile care întorc erori ar trebui să aibă tipul de retur error, nu un tip concret precum *MyErr, și să întoarcă nil literal pe calea de succes.

Poți vedea ce e în interfață cu:

GO
err := run()
fmt.Printf("%T %v\n", err, err == nil) // *main.MyErr false

Aceeași capcană apare cu orice interfață, nu doar cu error: de exemplu un io.Reader care conține un *bytes.Buffer nil. Pentru verificări sigure de tip folosește errors.As, nu comparații cu tipuri concrete.

Ce urmărește intervievatorul: Este una dintre cele mai cunoscute capcane din Go. Se verifică dacă înțelegi reprezentarea internă a interfețelor, nu doar sintaxa.

25 Mid

Ce sunt method sets? De ce codul var s Shape = Square{} nu compilează dacă Area() are pointer receiver?

Răspuns scurt: Method set-ul unui tip T conține doar metodele cu value receiver, iar al lui *T le conține pe toate. Dacă Area() e definită pe *Square, atunci doar *Square implementează Shape, deci trebuie să scrii var s Shape = &Square{}.

Codul în cauză:

GO
type Shape interface{ Area() float64 }

type Square struct{ Side float64 }

func (s *Square) Area() float64 { return s.Side * s.Side }

var s Shape = Square{Side: 2}
// eroare: Square does not implement Shape (method Area has pointer receiver)
var ok Shape = &Square{Side: 2} // compilează

Regulile:

  • tipul T are în method set metodele declarate cu receiver T;
  • tipul *T are metodele cu receiver T și pe cele cu receiver *T.

De ce această asimetrie? Când pui o valoare Square într-o interfață, interfața reține o copie. O metodă cu pointer receiver ar modifica acea copie internă, nu originalul, ceea ce ar fi un comportament surprinzător. În plus, valoarea din interfață nu este adresabilă, deci Go nu poate lua automat &.

De ce atunci merge sq.Area() pe o variabilă sq := Square{}? Pentru că o variabilă este adresabilă, iar compilatorul rescrie apelul în (&sq).Area(). Este doar o comoditate la apel direct, nu se aplică la satisfacerea interfețelor. Nu merge nici pe valori neadresabile, cum ar fi elementele unui map: m["a"].Area() nu compilează.

Practic: dacă tipul tău are metode cu pointer receiver, lucrează cu el prin pointer (constructor NewSquare care întoarce *Square) și transmite pointeri în interfețe. Amestecul de receivere pe același tip e de obicei semn de inconsistență.

Ce urmărește intervievatorul: Verifică dacă poți citi și explica o eroare de compilare frecventă. Mulți candidați „repară” punând & fără să știe de ce funcționează.

26 Mid

Cum arată un slice în memorie și cum poate un sub-slice să țină ocupată memorie inutil? Ce face expresia s[low:high:max]?

Răspuns scurt: Un slice este un antet cu trei câmpuri: pointer spre array-ul de bază, lungime și capacitate. Un sub-slice mic dintr-un array mare ține tot array-ul în viață pentru GC. Expresia cu trei indici limitează capacitatea, iar pentru eliberarea memoriei trebuie să copiezi datele.

Antetul unui slice e, conceptual:

GO
type sliceHeader struct {
	Data unsafe.Pointer
	Len  int
	Cap  int
}

Pe 64 de biți are 24 de bytes, indiferent câte elemente sunt. Transmiterea unui slice copiază doar antetul.

Problema de memorie: citești un fișier de 100 MB și păstrezi doar primii 16 bytes ca identificator:

GO
data, _ := os.ReadFile("dump.bin")
id := data[:16] // ține în viață toți cei 100 MB

Cât timp id e referit (de exemplu într-un cache), garbage collector-ul nu poate elibera array-ul de bază, pentru că id indică spre el. Soluția este o copie:

GO
id := bytes.Clone(data[:16]) // Go 1.20+
// sau: id := append([]byte(nil), data[:16]...)

Aceeași problemă apare cu string-uri obținute prin tăiere dintr-un string mare; acolo se folosește strings.Clone (Go 1.20).

Full slice expression s[low:high:max] creează un slice cu len = high-low și cap = max-low. Nu eliberează memorie, dar protejează datele originale de suprascriere:

GO
base := []int{1, 2, 3, 4}
head := base[0:2:2] // len 2, cap 2
head = append(head, 9) // alocă array nou
fmt.Println(base) // [1 2 3 4], neatins

Un alt detaliu legat de memorie: la ștergerea elementelor dintr-un slice de pointeri, elementele rămase după len încă țin obiecte în viață. slices.Delete le pune pe zero începând cu Go 1.22.

Ce urmărește intervievatorul: Diferențiază un candidat care a depanat consum de memorie de unul care știe doar sintaxa. Semnal bun: menționează copierea explicită pentru eliberare.

27 Senior

Cum este implementat un map în Go? De ce nu poți lua adresa unui element (&m[k]) și de ce nu e sigur pentru folosire concurentă?

Răspuns scurt: Map-ul e un hash table gestionat de runtime; din Go 1.24 folosește Swiss Tables. Elementele se mută când tabela crește, deci &m[k] e interzis. Nu are sincronizare internă, iar scrierile concurente pot opri procesul cu eroare fatală.

Un map calculează hash-ul cheii (cu un seed aleator per map, ca protecție împotriva atacurilor de tip hash flooding) și plasează perechea într-un grup sau bucket. Până la Go 1.23 implementarea folosea bucket-uri cu câte 8 perechi și overflow buckets; Go 1.24 a trecut la un design bazat pe Swiss Tables, cu grupuri și metadate de control care permit căutări mai rapide. Pentru codul tău, API-ul și garanțiile au rămas aceleași.

De ce nu &m[k]: când map-ul crește, runtime-ul mută perechile în locații noi. Un pointer la un element ar deveni invalid. De aceea nici nu poți modifica direct un câmp dintr-o valoare struct:

GO
m := map[string]User{}
m["a"].Name = "Ana" // nu compilează
u := m["a"]; u.Name = "Ana"; m["a"] = u // varianta corectă
// sau map[string]*User

Concurență: map-ul nu are lock-uri interne, pentru că majoritatea folosirilor nu sunt concurente și ar plăti costul degeaba. Runtime-ul face o verificare ieftină și, dacă o prinde, oprește procesul cu fatal error: concurrent map writes, care nu poate fi prins cu recover. Detecția nu e garantată, deci folosește go test -race.

Opțiuni:

  • sync.RWMutex + map: cea mai clară pentru majoritatea cazurilor;
  • sync.Map: optimizat pentru chei scrise o dată și citite des, sau pentru goroutines care lucrează pe chei disjuncte; nu e generic și pierde tipurile;
  • sharding: mai multe map-uri cu câte un mutex, după hash-ul cheii, pentru contention mare.

Map-urile nu își micșorează memoria după ștergeri; pentru un map care a fost foarte mare, recrearea lui eliberează spațiul.

Ce urmărește intervievatorul: Întrebare de profunzime pentru senior. Se verifică dacă știi de ce există restricțiile, nu doar că există, și dacă alegi corect între mutex și sync.Map.

28 Senior

Cum proiectezi interfețele într-un serviciu Go? Ce înseamnă „accept interfaces, return structs”?

Răspuns scurt: Interfețele bune în Go sunt mici, definite de pachetul care le consumă și descoperite din nevoi reale, nu create din reflex pentru fiecare tip. Funcțiile primesc interfețe, ca să fie flexibile la input, și întorc tipuri concrete, ca apelantul să aibă acces complet.

Principiile, pe scurt:

  • Interfețe mici. io.Reader are o singură metodă și e implementată de fișiere, conexiuni de rețea, body-uri HTTP, buffere, compresoare. Cu cât interfața e mai mică, cu atât e mai ușor de satisfăcut și de compus.
  • Definite la consumator. Serviciul de comenzi are nevoie doar să salveze o comandă, deci își declară:
GO
package orders

type OrderStore interface {
	Save(ctx context.Context, o Order) error
}

type Service struct{ store OrderStore }

func NewService(s OrderStore) *Service { return &Service{store: s} }

Pachetul postgres exportă un *Repo concret, cu toate metodele lui, fără să cunoască interfața. Asta evită dependențe circulare și interfețe uriașe de tip „Repository cu 30 de metode” pe care fiecare test trebuie să le implementeze.

  • Return structs. NewService întoarce *Service, nu o interfață. Apelantul vede toate metodele, documentația e clară, iar adăugarea unei metode noi nu strică pe nimeni. Excepția legitimă: când există mai multe implementări reale ascunse în spatele unui constructor, sau la tipul error.

Greșeli frecvente aduse din alte limbaje:

  • interfață IUserService creată lângă singura ei implementare, doar „pentru teste”;
  • interfețe care expun detalii de stocare (QueryRow, Tx) în stratul de business;
  • prea multă abstractizare devreme; în Go e ieftin să extragi o interfață mai târziu, tocmai pentru că implementarea e implicită.

Compoziția rezolvă nevoile mai mari: type ReadCloser interface { Reader; Closer }.

Ce urmărește intervievatorul: Arată maturitatea de design. Intervievatorul caută argumente legate de decuplare și testare, nu reguli recitate.

Tratarea erorilor

29 Junior

Cum se tratează erorile în Go și de ce limbajul nu folosește excepții?

Răspuns scurt: În Go o eroare este o valoare obișnuită care implementează interfața error, întoarsă ca ultim rezultat al funcției și verificată explicit cu if err != nil. Designul face ca fiecare punct de eșec să fie vizibil în cod.

Interfața este minimă:

GO
type error interface {
	Error() string
}

Idiomul de bază:

GO
cfg, err := loadConfig("app.yaml")
if err != nil {
	return fmt.Errorf("pornire server: %w", err)
}

De ce nu excepții? Argumentul autorilor Go este că excepțiile creează un flux de control ascuns: orice apel poate sări brusc câteva niveluri mai sus, iar din cod nu se vede ce poate eșua. Cu erori ca valori:

  • citești funcția și vezi exact unde poate eșua și ce se întâmplă atunci;
  • ești forțat să decizi la fiecare pas: tratezi, adaugi context și întorci, sau ignori explicit cu _;
  • erorile se pot inspecta, compune și transmite ca orice valoare (prin canale, în slice-uri).

Costul este verbozitatea: multe linii if err != nil. În practică, valoarea vine din contextul adăugat la fiecare nivel. Un mesaj final ca procesare comandă 42: salvare: conexiune refuzată spune direct unde a apărut problema.

Reguli bune de urmat:

  • nu ignora erorile fără motiv; linter-ul errcheck le prinde;
  • verifică eroarea înainte să folosești celelalte valori întoarse;
  • mesajele de eroare se scriu cu literă mică și fără punct la final, pentru că vor fi concatenate;
  • panic e pentru bug-uri, nu pentru erori de business.

Ce urmărește intervievatorul: Verifică dacă ai acceptat filozofia limbajului și știi să adaugi context. Candidații care se plâng doar de verbozitate fără să explice avantajele pierd puncte.

30 Junior

Cum creezi o eroare proprie în Go? Când folosești errors.New, fmt.Errorf sau un tip custom?

Răspuns scurt: errors.New creează o eroare cu mesaj fix, fmt.Errorf una cu mesaj formatat (și poate împacheta altă eroare cu %w), iar un tip custom e un struct cu metoda Error(), folosit când apelantul are nevoie de date suplimentare despre eroare.

Trei niveluri, în ordinea complexității:

GO
// 1. Mesaj fix, adesea ca sentinel exportat
var ErrNotFound = errors.New("not found")

// 2. Mesaj cu context dinamic
return fmt.Errorf("utilizatorul %d nu are acces la comanda %d", userID, orderID)

// 3. Tip propriu, cu câmpuri
type ValidationError struct {
	Field  string
	Reason string
}

func (e *ValidationError) Error() string {
	return fmt.Sprintf("câmp %s invalid: %s", e.Field, e.Reason)
}

func validate(u User) error {
	if !strings.Contains(u.Email, "@") {
		return &ValidationError{Field: "email", Reason: "lipsește @"}
	}
	return nil
}

Cum alegi:

  • errors.New pentru erori pe care apelantul le recunoaște după identitate (ErrNotFound, io.EOF). Le declari o dată, la nivel de pachet, ca variabile.
  • fmt.Errorf pentru majoritatea cazurilor în care doar adaugi context; cu %w păstrezi eroarea originală pentru inspecție.
  • Tip custom când apelantul are nevoie de informații structurate: câmpul invalid, codul de status de la un API extern, durata după care poate reîncerca. Handler-ul HTTP poate extrage Field și răspunde cu 400 și un mesaj util.

Detaliu: tipul custom are de obicei metoda Error() pe pointer receiver și se întoarce ca &ValidationError{}. Iar funcția trebuie să aibă tipul de retur error, nu *ValidationError, ca să eviți capcana interfeței nenule care conține un pointer nil.

Ce urmărește intervievatorul: Verifică dacă alegi unealta potrivită în funcție de ce are nevoie apelantul. Greșeala tipică: comparații pe textul erorii (err.Error() == "...").

31 Mid

Ce înseamnă wrapping de erori? Explică %w, errors.Is și errors.As.

Răspuns scurt: Wrapping înseamnă să adaugi context unei erori păstrând-o pe cea originală, cu fmt.Errorf("...: %w", err). errors.Is caută o anumită eroare în lanț, iar errors.As caută un anumit tip și îl extrage. Există din Go 1.13.

Fără wrapping, adăugarea de context distruge informația: fmt.Errorf("get user: %v", err) produce doar un string nou, iar apelantul nu mai poate afla că la bază a fost sql.ErrNoRows. Cu %w, eroarea nouă reține eroarea veche și o expune prin metoda Unwrap().

GO
func (r *Repo) GetUser(ctx context.Context, id int64) (User, error) {
	var u User
	err := r.db.QueryRowContext(ctx, `SELECT id, email FROM users WHERE id = $1`, id).
		Scan(&u.ID, &u.Email)
	if err != nil {
		return User{}, fmt.Errorf("get user %d: %w", id, err)
	}
	return u, nil
}

// în handler
u, err := repo.GetUser(ctx, 7)
if errors.Is(err, sql.ErrNoRows) {
	http.Error(w, "user inexistent", http.StatusNotFound)
	return
}

var pgErr *pgconn.PgError
if errors.As(err, &pgErr) && pgErr.Code == "23505" {
	// încălcare de unicitate
}

Diferențe importante:

  • err == sql.ErrNoRows nu mai funcționează după wrapping; folosește mereu errors.Is.
  • errors.As primește un pointer la variabila țintă; dacă tipul implementează error cu pointer receiver, ținta e **T, scrisă ca &pgErr.
  • Din Go 1.20, fmt.Errorf acceptă mai mulți %w în același apel, iar Is/As caută prin toți.

Decizie de design: wrapping-ul face din eroarea internă parte din API-ul tău. Dacă nu vrei ca apelanții să depindă de faptul că folosești PostgreSQL, folosește %v sau traduce eroarea într-una a ta (ErrNotFound).

Ce urmărește intervievatorul: E o întrebare standard la mid. Se verifică dacă știi că == nu merge după wrapping și dacă te gândești la ce expui prin lanțul de erori.

32 Mid

Ce sunt sentinel errors? Care sunt avantajele și dezavantajele lor față de tipurile de eroare?

Răspuns scurt: Sentinel errors sunt valori de eroare exportate, predefinite, precum io.EOF sau sql.ErrNoRows, recunoscute prin identitate cu errors.Is. Sunt simple, dar nu poartă date și devin parte din API-ul public al pachetului. Tipurile de eroare permit date structurate, cu prețul unei cuplări mai mari.

Există trei strategii principale pentru ca apelantul să reacționeze la o eroare:

  • Sentinel: var ErrNotFound = errors.New("not found"). Apelantul scrie errors.Is(err, store.ErrNotFound). Simplu și clar pentru câteva cazuri bine definite.
  • Tip de eroare: type RateLimitError struct{ RetryAfter time.Duration }, verificat cu errors.As. Util când apelantul are nevoie de detalii.
  • Comportament (opaque errors): apelantul nu știe tipul concret, ci verifică o interfață:
GO
type temporary interface{ Temporary() bool }

func isRetryable(err error) bool {
	var t temporary
	return errors.As(err, &t) && t.Temporary()
}

Dezavantajele sentinel-urilor:

  • devin contract public; odată exportat ErrNotFound, nu-l mai poți elimina fără să strici apelanții;
  • creează dependență de pachet: cine verifică store.ErrNotFound trebuie să importe store;
  • nu pot spune *ce* nu a fost găsit, decât prin mesajul de wrapping.

Dezavantajele tipurilor: aceeași cuplare, plus mai mult cod.

O abordare practică într-un serviciu: un set mic de erori de domeniu definite într-un pachet central (ErrNotFound, ErrConflict, ErrForbidden, ErrInvalidInput), în care stratul de date traduce erorile driverului. Stratul HTTP le mapează la status code-uri. Astfel, handler-ele nu știu nimic de PostgreSQL, iar business logic-ul nu știe nimic de HTTP.

Regula care te ferește de probleme: nu compara niciodată pe text, cu strings.Contains(err.Error(), ...), pentru că mesajele se schimbă fără avertisment.

Ce urmărește intervievatorul: Testează gândirea despre API și cuplare. Un candidat bun cântărește variantele în loc să declare una „corectă”.

33 Mid

Unde ar trebui logată o eroare? De ce este problematic pattern-ul „log and return”?

Răspuns scurt: O eroare ar trebui tratată o singură dată: fie o loghezi și o consumi, fie îi adaugi context și o întorci, nu ambele. Logarea la fiecare nivel produce aceeași eroare de mai multe ori în loguri, fără context comun, și face depanarea mai grea.

Varianta problematică:

GO
func (s *Service) PlaceOrder(ctx context.Context, o Order) error {
	if err := s.repo.Save(ctx, o); err != nil {
		log.Printf("eroare la salvare: %v", err) // logat aici
		return err                              // și întors
	}
	return nil
}

Dacă și handler-ul loghează, iar repository-ul a logat la rândul lui, ai trei linii pentru același incident, fără legătură evidentă între ele, iar alertele pe numărul de erori devin false.

Varianta recomandată: nivelurile de jos adaugă context și întorc, iar marginea sistemului (handler-ul HTTP, consumer-ul de coadă, job-ul) decide și loghează o singură dată:

GO
if err := s.repo.Save(ctx, o); err != nil {
	return fmt.Errorf("place order %s: %w", o.ID, err)
}

// în handler
if err := svc.PlaceOrder(r.Context(), o); err != nil {
	slog.ErrorContext(r.Context(), "place order failed",
		"err", err, "user_id", userID, "request_id", reqID)
	writeError(w, err)
	return
}

Linia finală conține întregul lanț de context plus atribute structurate pe care le poți căuta.

Excepții legitime de la regulă:

  • erori pe care le consumi deliberat (un retry reușit, un cache indisponibil cu fallback): le loghezi ca warn și nu le mai întorci;
  • goroutines de fundal, care nu au cui să întoarcă eroarea.

Go nu atașează stack trace-ul la erori. Contextul din mesaje ține locul lui, deci un mesaj bun spune ce operație și pe ce entitate a eșuat.

Ce urmărește intervievatorul: Arată experiență cu loguri reale în producție. Semnal rău: „loghez peste tot ca să fiu sigur”.

34 Mid

Cum combini mai multe erori într-una singură? Ce face errors.Join?

Răspuns scurt: errors.Join (Go 1.20) întoarce o eroare care conține toate erorile primite, ignorând valorile nil; dacă toate sunt nil, întoarce nil. errors.Is și errors.As caută în toate erorile combinate. E util la validare, la cleanup sau când mai multe operații independente pot eșua.

Exemplu tipic, validarea unui formular în care vrei să raportezi toate problemele, nu doar prima:

GO
func (r CreateUserRequest) Validate() error {
	var errs []error
	if r.Email == "" {
		errs = append(errs, errors.New("email obligatoriu"))
	}
	if len(r.Password) < 12 {
		errs = append(errs, errors.New("parola trebuie să aibă minimum 12 caractere"))
	}
	return errors.Join(errs...) // nil dacă slice-ul e gol
}

Mesajul erorii combinate pune fiecare eroare pe o linie separată.

Un alt caz frecvent este eroarea de la Close(), care nu trebuie pierdută la scriere:

GO
func writeReport(path string, data []byte) (err error) {
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	defer func() {
		err = errors.Join(err, f.Close())
	}()
	_, err = f.Write(data)
	return err
}

La fișiere scrise, Close poate raporta erori reale (de exemplu disc plin la flush), iar un simplu defer f.Close() le ignoră.

Detalii tehnice: eroarea întoarsă implementează Unwrap() []error, forma introdusă în Go 1.20 pentru erori multiple. Dacă ai propriul tip care agregă erori, implementează aceeași metodă ca să funcționeze cu errors.Is/As.

Pentru erori din mai multe goroutines, errgroup întoarce doar prima eroare. Dacă ai nevoie de toate, le colectezi cu un mutex sau un canal și le combini la final cu errors.Join.

Ce urmărește intervievatorul: Verifică dacă ții pasul cu biblioteca standard și dacă știi să nu pierzi erori la cleanup, o problemă des ignorată.

35 Senior

Cum transformi erorile din stratul de business în răspunsuri HTTP fără să expui detalii interne clientului?

Răspuns scurt: Definești câteva erori de domeniu, stratul de date traduce erorile tehnice în ele, iar un singur helper HTTP le mapează la status code și mesaj public. Detaliile complete ajung doar în loguri, legate de un request ID.

Problema apare când un handler face http.Error(w, err.Error(), 500): clientul primește mesaje ca pq: duplicate key value violates unique constraint "users_email_key", adică detalii despre schemă și tehnologie, utile unui atacator și inutile utilizatorului.

O structură care funcționează bine:

GO
package apperr

var (
	ErrNotFound = errors.New("not found")
	ErrConflict = errors.New("conflict")
	ErrInvalid  = errors.New("invalid input")
)

type PublicError struct {
	Err     error  // una dintre sentinelele de mai sus
	Message string // sigur de arătat clientului
}

func (e *PublicError) Error() string { return e.Message }
func (e *PublicError) Unwrap() error { return e.Err }

Repository-ul traduce: codul PostgreSQL 23505 devine &PublicError{Err: ErrConflict, Message: "emailul este deja folosit"}.

Un singur helper în stratul HTTP:

GO
func writeError(w http.ResponseWriter, r *http.Request, err error) {
	status, msg := http.StatusInternalServerError, "eroare internă"
	var pe *apperr.PublicError
	if errors.As(err, &pe) {
		msg = pe.Message
		switch {
		case errors.Is(err, apperr.ErrNotFound):
			status = http.StatusNotFound
		case errors.Is(err, apperr.ErrConflict):
			status = http.StatusConflict
		case errors.Is(err, apperr.ErrInvalid):
			status = http.StatusBadRequest
		}
	}
	if status >= 500 {
		slog.ErrorContext(r.Context(), "request failed", "err", err)
	}
	writeJSON(w, status, map[string]string{"error": msg, "request_id": requestID(r.Context())})
}

Avantaje: o politică unitară, coduri corecte (4xx față de 5xx contează pentru alerte și retry-uri), iar request ID-ul leagă răspunsul de linia de log. Un format standard de corp pentru erori este RFC 9457 (Problem Details).

Ce urmărește intervievatorul: Este o întrebare de arhitectură și securitate. Se verifică separarea straturilor și conștientizarea scurgerilor de informații prin mesaje de eroare.

Concurență: goroutines, canale, context

36 Junior

Ce este o goroutine și cum diferă de un thread al sistemului de operare?

Răspuns scurt: O goroutine este o funcție care rulează concurent, gestionată de runtime-ul Go. Pornește cu un stack de câțiva KB care crește la nevoie și e planificată pe un număr mic de thread-uri OS, deci poți avea zeci de mii.

Pornești o goroutine cu cuvântul go în fața unui apel:

GO
func main() {
	go sendEmail("ana@exemplu.ro")
	fmt.Println("comandă salvată")
	time.Sleep(100 * time.Millisecond) // doar pentru demonstrație
}

Diferențe față de un thread OS:

  • Memorie: un thread are de obicei un stack fix de ordinul megabyților; o goroutine pornește cu aproximativ 2 KB, iar stack-ul crește și scade dinamic.
  • Creare și comutare: crearea unui thread implică kernel-ul; o goroutine e creată în spațiul utilizatorului, iar comutarea între goroutines e mult mai ieftină.
  • Planificare: runtime-ul Go distribuie goroutines pe thread-uri (modelul M:N). Când o goroutine se blochează pe I/O de rețea, runtime-ul o parchează și rulează alta pe același thread, folosind mecanismul de notificări al sistemului (epoll pe Linux).
  • Identitate: goroutines nu au ID accesibil programatorului și nu pot fi oprite din afară; se opresc singure, de obicei prin context sau prin închiderea unui canal.

Două reguli practice:

  • când main() se termină, programul se oprește, indiferent câte goroutines rulează. De aceea ai nevoie de sincronizare (sync.WaitGroup, canale), nu de time.Sleep;
  • fiecare goroutine pornită trebuie să aibă o cale clară de terminare, altfel apar goroutine leaks.

net/http pornește câte o goroutine per conexiune, ceea ce face serverele Go simple de scris în stil blocant.

Ce urmărește intervievatorul: Întrebare de bază pentru orice rol Go. Se urmărește dacă știi de modelul M:N și de faptul că main nu așteaptă goroutines.

37 Junior

Ce este un canal (channel)? Care e diferența dintre un canal unbuffered și unul buffered?

Răspuns scurt: Un canal este un conductor tipizat prin care goroutines trimit și primesc valori, sincronizându-se. Un canal unbuffered blochează trimițătorul până când cineva primește valoarea. Un canal buffered are o capacitate fixă și blochează trimițătorul doar când bufferul e plin.

Crearea și folosirea:

GO
ch := make(chan int)      // unbuffered
jobs := make(chan Job, 100) // buffered, capacitate 100

go func() { ch <- 42 }()  // trimitere
v := <-ch                 // primire
fmt.Println(v)            // 42

Unbuffered înseamnă un „rendez-vous”: trimiterea și primirea se întâmplă împreună. Când ch <- 42 se termină, ai garanția că o altă goroutine a primit valoarea. E potrivit pentru semnale și predări sincronizate.

Buffered decuplează temporar producătorul de consumator: trimițătorul poate pune până la cap(ch) valori fără să aștepte. E util pentru a absorbi vârfuri scurte sau pentru a limita concurența (un canal cu capacitate N folosit ca semafor).

GO
sem := make(chan struct{}, 5) // maximum 5 operații simultan
for _, u := range urls {
	sem <- struct{}{}
	go func(u string) {
		defer func() { <-sem }()
		fetch(u)
	}(u)
}

Reguli de comportament de reținut:

  • trimiterea sau primirea pe un canal nil blochează pentru totdeauna;
  • trimiterea pe un canal închis produce panic;
  • primirea dintr-un canal închis întoarce imediat zero value; forma v, ok := <-ch îți spune dacă e închis (ok == false).

Un buffer mare nu rezolvă un consumator prea lent; doar amână blocarea și ascunde problema. Mărimea bufferului ar trebui să aibă o justificare.

Ce urmărește intervievatorul: Verifică semantica de blocare, de care depind toate pattern-urile concurente. Greșeala tipică: a crede că buffered înseamnă asincron fără limită.

38 Junior

Cum aștepți terminarea mai multor goroutines? Cum se folosește sync.WaitGroup?

Răspuns scurt: sync.WaitGroup este un contor: apelezi Add înainte de a porni goroutines, fiecare apelează Done la final, iar Wait blochează până când contorul ajunge la zero. Din Go 1.25 există și wg.Go(f), care face Add, pornirea și Done într-un singur apel.

Exemplu clasic:

GO
func fetchAll(urls []string) {
	var wg sync.WaitGroup
	for _, u := range urls {
		wg.Add(1)
		go func() {
			defer wg.Done()
			fetch(u)
		}()
	}
	wg.Wait()
	fmt.Println("toate cererile s-au terminat")
}

(Cu Go 1.22+, u este o variabilă nouă la fiecare iterație, deci closure-ul e corect.)

Greșeli frecvente:

  • Add în interiorul goroutinei: Wait poate rula înainte ca vreo goroutine să apuce să incrementeze contorul și se întoarce imediat. Add se apelează mereu înainte de go.
  • Uitarea lui Done pe o cale de eroare: Wait blochează pentru totdeauna. defer wg.Done() pe prima linie rezolvă problema.
  • Copierea WaitGroup-ului: transmis prin valoare unei funcții, fiecare copie are contorul ei. Se transmite prin pointer; go vet detectează copierea.

Varianta Go 1.25:

GO
var wg sync.WaitGroup
for _, u := range urls {
	wg.Go(func() { fetch(u) })
}
wg.Wait()

Limita lui WaitGroup: nu colectează erori și nu anulează celelalte goroutines când una eșuează. Pentru asta se folosește errgroup din golang.org/x/sync. Iar dacă ai nevoie de rezultate, le colectezi într-un slice cu index fix per goroutine (fiecare scrie la poziția ei, fără data race) sau printr-un canal.

Ce urmărește intervievatorul: Este sincronizarea de bază. Intervievatorul urmărește dacă știi de greșeala cu Add în goroutine, foarte comună la juniori.

39 Junior

Ce face instrucțiunea select și cum implementezi un timeout cu ea?

Răspuns scurt: select așteaptă pe mai multe operații cu canale și o execută pe prima care devine posibilă; dacă mai multe sunt gata simultan, alege una aleator. Un timeout se face adăugând un caz pe time.After sau pe ctx.Done().

Forma generală:

GO
select {
case msg := <-messages:
	fmt.Println("primit:", msg)
case err := <-errs:
	fmt.Println("eroare:", err)
case <-time.After(2 * time.Second):
	fmt.Println("timeout")
}

Fără default, select blochează până când un caz e gata. Cu default, devine neblocant:

GO
select {
case queue <- job:
	// trimis
default:
	// coada e plină: respingi cererea în loc să blochezi
	return ErrBusy
}

E un mod simplu de a face load shedding sau trimiteri „best effort”.

În cod de producție, timeout-ul vine de obicei din context, ca anularea să se propage:

GO
func waitResult(ctx context.Context, results <-chan Result) (Result, error) {
	select {
	case r := <-results:
		return r, nil
	case <-ctx.Done():
		return Result{}, ctx.Err() // context.DeadlineExceeded sau Canceled
	}
}

Detalii utile:

  • un select {} gol blochează pentru totdeauna;
  • un caz pe un canal nil nu e niciodată selectat, truc folosit pentru a „dezactiva” un caz după ce canalul s-a închis;
  • time.After într-o buclă care rulează des creează un timer nou la fiecare iterație. Începând cu Go 1.23 timer-urile nefolosite sunt colectate de GC, dar pentru bucle e mai clar să folosești un time.Timer sau time.Ticker reutilizat;
  • alegerea aleatoare între cazuri gata înseamnă că nu există prioritate implicită.

Ce urmărește intervievatorul: Verifică dacă știi construcțiile de bază pentru timeout și neblocare. Semnal bun: preferi ctx.Done() față de time.After în cod real.

40 Junior

Cine ar trebui să închidă un canal și ce se întâmplă când faci range pe un canal?

Răspuns scurt: Canalul îl închide trimițătorul, niciodată primitorul, și doar când nu mai urmează valori. for v := range ch citește până când canalul e închis și golit. Un canal neînchis nu e o problemă: GC-ul îl eliberează.

Pattern-ul de bază producător-consumator:

GO
func produce(n int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out) // producătorul închide
		for i := 0; i < n; i++ {
			out <- i
		}
	}()
	return out
}

for v := range produce(3) {
	fmt.Println(v) // 0 1 2, apoi bucla iese
}

De ce închide trimițătorul: doar el știe când nu mai are ce trimite. Dacă primitorul închide canalul, iar trimițătorul încearcă încă o trimitere, programul face panic (send on closed channel). Alte reguli:

  • închiderea unui canal deja închis produce panic;
  • închiderea unui canal nil produce panic;
  • primirea dintr-un canal închis întoarce imediat zero value, deci v, ok := <-ch cu ok == false semnalează închiderea.

Cu mai mulți producători pe același canal, niciunul nu poate închide singur. Soluția: un WaitGroup și o goroutine separată care închide după ce toți au terminat:

GO
go func() {
	wg.Wait()
	close(out)
}()

Închiderea e utilă și ca semnal de broadcast: toți cei care așteaptă pe <-done sunt deblocați simultan. Așa funcționează intern și ctx.Done().

Direcția canalelor în semnături (<-chan int doar primire, chan<- int doar trimitere) face regulile verificabile la compilare: un consumator care primește <-chan nici nu poate apela close.

Ce urmărește intervievatorul: Testează disciplina de proprietate asupra canalelor. Răspunsul greșit tipic este „închide cine termină primul” sau „trebuie închise mereu”.

41 Junior

Ce se întâmplă la rularea codului următor și cum îl repari?

GO
func main() {
	ch := make(chan int)
	ch <- 1
	fmt.Println(<-ch)
}

Răspuns scurt: Programul se oprește cu fatal error: all goroutines are asleep - deadlock!. Trimiterea pe un canal unbuffered blochează până când altă goroutine primește, dar singura goroutine este main, care stă blocată la trimitere. Repari cu un canal buffered sau trimițând dintr-o altă goroutine.

Pas cu pas: ch <- 1 așteaptă un receptor. Receptorul ar fi <-ch de pe linia următoare, dar execuția nu ajunge acolo, pentru că main e blocată. Runtime-ul detectează că nu mai există nicio goroutine care ar putea progresa și oprește programul.

Două reparații corecte:

GO
// 1. trimiterea dintr-o altă goroutine
ch := make(chan int)
go func() { ch <- 1 }()
fmt.Println(<-ch)

// 2. canal buffered cu loc pentru o valoare
ch := make(chan int, 1)
ch <- 1
fmt.Println(<-ch)

Alte surse frecvente de deadlock:

  • range pe un canal pe care nu-l închide nimeni: după ultima valoare, bucla așteaptă la nesfârșit;
  • wg.Wait() când o goroutine nu apelează Done;
  • două goroutines care așteaptă fiecare un mesaj de la cealaltă;
  • un mutex blocat de două ori în aceeași goroutine (mutex-urile din Go nu sunt reentrante).

Atenție: detecția automată funcționează doar când toate goroutines sunt blocate. Într-un server HTTP există mereu goroutines active (listener-ul, timer-ele), deci un deadlock parțial nu oprește procesul; doar anumite cereri rămân agățate pentru totdeauna. Acolo îl depanezi cu un dump de goroutines: curl localhost:6060/debug/pprof/goroutine?debug=2 cu net/http/pprof activat, sau semnalul SIGQUIT, care afișează stack-ul tuturor goroutinelor.

Ce urmărește intervievatorul: Este un exercițiu clasic de „ce se întâmplă”. Se verifică semantica canalelor unbuffered și dacă știi că într-un server deadlock-ul nu va fi semnalat automat.

42 Junior

Ce este un data race, cum îl detectezi și cum îl previi cu sync.Mutex?

Răspuns scurt: Un data race apare când două goroutines accesează aceeași variabilă simultan, cel puțin una scrie și nu există sincronizare. Îl detectezi cu flag-ul -race și îl previi cu mutex, operații atomice sau canale.

Exemplu cu bug:

GO
var count int
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
	wg.Add(1)
	go func() {
		defer wg.Done()
		count++ // citire, adunare, scriere: nu e atomic
	}()
}
wg.Wait()
fmt.Println(count) // adesea mai puțin de 1000

count++ înseamnă trei pași. Două goroutines pot citi aceeași valoare și scrie același rezultat, deci incrementări se pierd. Mai grav, modelul de memorie Go nu garantează nimic pentru un program cu data race, inclusiv valori „rupte” la tipuri mai mari decât un cuvânt de procesor.

Reparația cu mutex:

GO
type Counter struct {
	mu sync.Mutex
	n  int
}

func (c *Counter) Inc() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.n++
}

Pentru un contor simplu, atomic.Int64 (Go 1.19) este mai ușor: c.Add(1).

Race detector-ul instrumentează accesele la memorie la rulare și raportează locurile exacte ale celor două accese concurente. Limitări: găsește doar race-urile care chiar se întâmplă în execuția dată, deci are nevoie de teste care exersează codul concurent, și încetinește programul de câteva ori. De aceea se rulează în CI pe teste, nu în producție.

Reguli practice: ține mutex-ul cât mai puțin timp, nu face I/O ținând lock-ul, nu copia struct-uri care conțin mutex și documentează ce câmpuri protejează fiecare mutex.

Ce urmărește intervievatorul: Concurența fără sincronizare e cea mai frecventă clasă de bug-uri în Go. Intervievatorul vrea să audă de -race și de ce count++ nu e sigur.

43 Mid

Ce este context.Context și cum îl folosești pentru anulare și timeout-uri?

Răspuns scurt: context.Context transportă printr-un lanț de apeluri un semnal de anulare, un deadline și valori legate de request. Îl creezi cu context.WithTimeout sau WithCancel, îl dai ca prim argument fiecărei funcții care face I/O, iar acestea se opresc când ctx.Done() se închide.

Problema rezolvată: un client închide conexiunea sau un request depășește timpul alocat, dar serverul continuă interogări la baza de date și apeluri către alte servicii pentru un răspuns pe care nu-l mai așteaptă nimeni. Context-ul propagă decizia de anulare prin toate nivelurile.

GO
func (h *Handler) GetReport(w http.ResponseWriter, r *http.Request) {
	ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
	defer cancel() // eliberează resursele timer-ului

	rep, err := h.svc.BuildReport(ctx, r.PathValue("id"))
	if errors.Is(err, context.DeadlineExceeded) {
		http.Error(w, "timeout", http.StatusGatewayTimeout)
		return
	}
	// ...
}

func (s *Service) BuildReport(ctx context.Context, id string) (Report, error) {
	rows, err := s.db.QueryContext(ctx, `SELECT ... WHERE id = $1`, id)
	// ...
}

r.Context() e anulat automat când clientul se deconectează. QueryContext, http.NewRequestWithContext și clienții gRPC respectă anularea.

Reguli convenționale:

  • ctx este primul parametru și nu se stochează în struct-uri;
  • apelează mereu cancel(), de obicei cu defer, altfel resursele rămân alocate până la expirare (go vet avertizează);
  • un context copil nu poate prelungi deadline-ul părintelui, doar îl poate scurta;
  • context.Background() doar în main, în teste sau la rădăcina unui job;
  • context.WithValue doar pentru date de request (request ID, utilizator autentificat), cu chei de tip propriu neexportat, nu pentru parametri opționali.

În codul tău cu bucle lungi verifici explicit ctx.Err() sau folosești select pe ctx.Done(). Din Go 1.20 există context.Cause, iar din 1.21 context.WithoutCancel pentru lucru care trebuie să continue după request.

Ce urmărește intervievatorul: E esențială pentru orice serviciu Go. Se verifică dacă propagi contextul real, nu context.Background() în mijlocul codului, și dacă știi de defer cancel().

44 Mid

Ce este un goroutine leak, cum apare și cum îl previi?

Răspuns scurt: Un goroutine leak este o goroutine blocată pentru totdeauna, de obicei pe un canal sau pe un I/O fără timeout. Ocupă memorie, iar numărul lor crește în timp. Îl previi dând fiecărei goroutine o cale garantată de ieșire.

Exemplu tipic:

GO
func firstResult(ctx context.Context, q string) (string, error) {
	ch := make(chan string) // unbuffered
	go func() {
		ch <- slowSearch(q) // blocată pentru totdeauna dacă nimeni nu mai citește
	}()
	select {
	case r := <-ch:
		return r, nil
	case <-ctx.Done():
		return "", ctx.Err() // goroutina de mai sus rămâne agățată
	}
}

La fiecare timeout rămâne o goroutine blocată la trimitere. La mii de request-uri pe minut, memoria crește constant până la restart.

Reparații:

GO
ch := make(chan string, 1) // trimiterea reușește chiar dacă nu mai citește nimeni

sau transmiterea contextului în slowSearch, ca munca să se oprească efectiv.

Cauze frecvente:

  • trimitere pe canal fără receptor sau range pe un canal care nu se închide;
  • worker-i care nu ascultă de ctx.Done();
  • apeluri HTTP cu http.Client fără timeout;
  • time.Ticker neoprit sau consumatori de coadă fără mecanism de oprire.

Cum îl observi și testezi:

  • metrica go_goroutines (expusă de clientul Prometheus) care crește continuu;
  • profilul pprof de goroutines, care arată mii de goroutines blocate în același loc;
  • în teste, biblioteca go.uber.org/goleak verifică la final că nu au rămas goroutines pornite.

Regula de design: cine pornește o goroutine e responsabil și de oprirea ei, iar funcțiile care pornesc goroutines ar trebui să ofere un mod de a aștepta terminarea lor.

Ce urmărește intervievatorul: Verifică experiența cu servicii care rulează mult timp. Candidații puternici descriu și cum ar observa problema în producție.

45 Mid

Scrie un worker pool: N goroutines care procesează joburi dintr-un canal și trimit rezultatele înapoi.

Răspuns scurt: Creezi un canal de joburi și unul de rezultate, pornești N worker-i care citesc cu range din canalul de joburi, iar după ce trimiți toate joburile închizi canalul. O goroutine separată așteaptă worker-ii cu WaitGroup și închide canalul de rezultate.

Implementare completă, cu suport de anulare:

GO
type Result struct {
	ID  int
	Out string
	Err error
}

func process(ctx context.Context, ids []int, workers int) []Result {
	jobs := make(chan int)
	results := make(chan Result)

	var wg sync.WaitGroup
	for w := 0; w < workers; w++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for id := range jobs {
				out, err := handle(ctx, id)
				select {
				case results <- Result{ID: id, Out: out, Err: err}:
				case <-ctx.Done():
					return
				}
			}
		}()
	}

	go func() {
		defer close(jobs)
		for _, id := range ids {
			select {
			case jobs <- id:
			case <-ctx.Done():
				return
			}
		}
	}()

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

	var all []Result
	for r := range results {
		all = append(all, r)
	}
	return all
}

Puncte pe care intervievatorul le urmărește:

  • cine închide ce: producătorul închide jobs, iar results se închide doar după ce toți worker-ii au terminat;
  • trimiterea joburilor se face într-o goroutine separată; dacă ar fi făcută din funcția principală înaintea citirii rezultatelor, ar putea apărea deadlock;
  • toate operațiile blocante ascultă de ctx.Done(), deci nu rămân goroutines agățate;
  • erorile sunt transmise ca date în Result, nu pierdute;
  • numărul de worker-i limitează concurența față de resursa externă (baza de date, un API cu rate limit).

Ordinea rezultatelor nu e garantată. Dacă contează, sortezi după ID sau scrii într-un slice prealocat, la indexul jobului. Pentru cazuri simple, errgroup cu SetLimit face aceeași treabă cu mai puțin cod.

Ce urmărește intervievatorul: Este un exercițiu practic frecvent la interviurile Go. Se urmăresc închiderea corectă a canalelor, lipsa deadlock-urilor și tratarea anulării.

46 Mid

Când folosești sync.RWMutex, sync.Once și pachetul sync/atomic?

Răspuns scurt: RWMutex permite mai mulți cititori simultan sau un singur scriitor, util când citirile domină. sync.Once garantează că o inițializare rulează exact o dată, chiar cu apeluri concurente. atomic oferă operații indivizibile pe valori simple, precum contoare și flag-uri, fără lock.

sync.RWMutex, de exemplu pentru un cache de configurare citit la fiecare request și actualizat rar:

GO
type Cache struct {
	mu   sync.RWMutex
	data map[string]string
}

func (c *Cache) Get(k string) (string, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	v, ok := c.data[k]
	return v, ok
}

func (c *Cache) Set(k, v string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.data[k] = v
}

Atenție: RWMutex are un cost mai mare decât Mutex și nu ajută dacă secțiunile critice sunt foarte scurte sau dacă scrierile sunt frecvente. Măsoară înainte să alegi.

sync.Once pentru inițializare leneșă sigură:

GO
var (
	once   sync.Once
	client *http.Client
)

func Client() *http.Client {
	once.Do(func() { client = &http.Client{Timeout: 5 * time.Second} })
	return client
}

Din Go 1.21 există și sync.OnceValue și sync.OnceValues, care întorc direct rezultatul (și eroarea). Dacă funcția din Do face panic, Once o consideră executată.

sync/atomic: din Go 1.19 există tipuri ca atomic.Int64, atomic.Bool, atomic.Pointer[T]:

GO
var inFlight atomic.Int64
inFlight.Add(1)
defer inFlight.Add(-1)

atomic.Pointer e util pentru a înlocui atomic o configurare întreagă: cititorii fac Load() fără lock, iar actualizarea face Store() cu un obiect nou, imuabil.

Regula: atomics doar pentru o singură valoare independentă. Dacă două câmpuri trebuie să fie consistente între ele, ai nevoie de mutex.

Ce urmărește intervievatorul: Verifică dacă alegi primitiva potrivită și știi limitele fiecăreia. Semnal bun: menționezi că RWMutex nu e automat mai rapid.

47 Mid

Ce este errgroup și ce probleme rezolvă față de sync.WaitGroup?

Răspuns scurt: errgroup (pachetul golang.org/x/sync/errgroup) rulează un grup de goroutines, așteaptă terminarea lor și întoarce prima eroare apărută. Creat cu WithContext, anulează contextul comun la prima eroare, ca celelalte să se oprească, iar SetLimit limitează câte rulează simultan.

Scenariu tipic: o pagină de profil are nevoie de date din trei surse, apelate în paralel. Dacă una eșuează, nu are rost să le aștepți pe celelalte.

GO
import "golang.org/x/sync/errgroup"

func loadProfile(ctx context.Context, id int64) (Profile, error) {
	var p Profile
	g, ctx := errgroup.WithContext(ctx)

	g.Go(func() error {
		u, err := users.Get(ctx, id)
		p.User = u
		return err
	})
	g.Go(func() error {
		o, err := orders.Recent(ctx, id)
		p.Orders = o
		return err
	})
	g.Go(func() error {
		s, err := billing.Summary(ctx, id)
		p.Billing = s
		return err
	})

	if err := g.Wait(); err != nil {
		return Profile{}, fmt.Errorf("load profile %d: %w", id, err)
	}
	return p, nil
}

Fiecare goroutine scrie într-un câmp diferit, deci nu există data race, iar Wait stabilește relația happens-before necesară pentru a citi p după aceea.

Ce rezolvă față de WaitGroup:

  • colectarea erorii, fără canale sau mutex-uri suplimentare;
  • anulare la prima eroare: contextul derivat e anulat, iar apelurile care respectă ctx se opresc;
  • nu mai există riscul de a uita Add/Done;
  • g.SetLimit(10) transformă grupul într-un worker pool simplu: Go blochează când sunt deja 10 active, iar TryGo încearcă fără blocare.

Limite: întoarce doar prima eroare (celelalte se pierd) și nu recuperează panicile din goroutines. Un detaliu de folosire corectă: după Wait, contextul derivat e deja anulat, deci nu-l folosi pentru operații ulterioare; folosește-l pe cel original.

Ce urmărește intervievatorul: E un pattern folosit zilnic în servicii Go. Se verifică dacă știi de anularea automată și de capcana folosirii contextului derivat după Wait.

48 Senior

Când alegi canale și când alegi un mutex? Ce înseamnă „Don't communicate by sharing memory; share memory by communicating”?

Răspuns scurt: Canalele sunt potrivite pentru transferul de proprietate asupra datelor și pentru coordonarea fluxurilor între goroutines (pipeline-uri, semnale, joburi). Mutex-ul e mai simplu și mai rapid pentru protejarea unei stări partajate, precum un cache sau un contor. Proverbul încurajează designul pe mesaje, nu interzice mutex-urile.

Proverbul vine din cultura Go și descrie un mod de a gândi: în loc ca mai multe goroutines să umble la aceeași structură sub lock, o singură goroutine deține datele, iar celelalte îi trimit cereri prin canale. Când o valoare e trimisă pe un canal, proprietatea trece la receptor, iar trimițătorul nu o mai atinge.

Când canalele sunt alegerea naturală:

  • un flux de date între etape (pipeline, fan-out/fan-in);
  • distribuirea de joburi la worker-i;
  • semnale de terminare sau notificări (done, ctx.Done());
  • așteptarea unui rezultat asincron, cu timeout prin select.

Când mutex-ul e mai bun:

  • o stare partajată accesată scurt: cache, contoare, registru de conexiuni;
  • cod în care o goroutine dedicată ar fi doar un mutex deghizat, mai lent și mai greu de citit:
GO
// complicat inutil
type Counter struct{ inc chan struct{}; get chan chan int }

// simplu și corect
type Counter struct {
	mu sync.Mutex
	n  int
}

Criterii de decizie pe care le-aș spune la interviu:

  • claritate: unde e mai ușor de demonstrat corectitudinea? Mutex-ul are o regulă simplă: datele X se ating doar ținând lock-ul Y.
  • performanță: o operație pe canal implică sincronizare internă și, adesea, planificarea altei goroutine; pentru secțiuni critice foarte scurte un mutex sau un atomic e de obicei mai ieftin. Diferența contează doar pe căi fierbinți și se măsoară cu benchmark-uri.
  • tipul problemei: coordonare și flux înseamnă canale; protecție de stare înseamnă mutex.

Biblioteca standard folosește ambele, iar mutex-urile apar foarte des în ea.

Ce urmărește intervievatorul: Evaluează judecata de design, nu dogma. Răspunsul slab este „mereu canale, pentru că așa e idiomatic”.

49 Senior

Cum funcționează scheduler-ul Go (modelul G-M-P) și ce rol are GOMAXPROCS, mai ales în containere?

Răspuns scurt: Scheduler-ul planifică goroutines (G) pe thread-uri OS (M) prin procesoare logice (P), fiecare cu coadă locală. GOMAXPROCS dă numărul de P. Din Go 1.25, pe Linux, valoarea implicită respectă limita de CPU a containerului.

Componentele modelului:

  • G: o goroutine, cu stack-ul și starea ei;
  • M: un thread al sistemului de operare;
  • P: un context de execuție necesar unui M ca să ruleze cod Go; are o coadă locală de goroutines gata de rulare.

Un M ia un P și rulează goroutines din coada lui. Mecanisme importante:

  • work stealing: un P cu coada goală fură goroutines din cozile altor P sau din coada globală, ca munca să se echilibreze;
  • network poller: o goroutine blocată pe un socket nu ține ocupat thread-ul; e parcată, iar când datele sosesc (epoll/kqueue) devine din nou rulabilă;
  • syscall-uri blocante: când un M intră într-un syscall lung (de exemplu I/O pe disc), P-ul lui e predat altui M, ca să nu se piardă paralelism; de aceea numărul de thread-uri poate depăși GOMAXPROCS;
  • preempțiune asincronă (din Go 1.14): o buclă strânsă fără apeluri de funcții nu mai poate monopoliza un P.

GOMAXPROCS implicit era numărul de CPU-uri vizibile de pe mașină. Într-un container Kubernetes cu limita de 2 CPU pe un nod cu 64 de nuclee, Go pornea 64 de P, iar thread-urile erau limitate de cgroup (CFS throttling), ceea ce producea latențe mari. Soluția uzuală era biblioteca go.uber.org/automaxprocs. Începând cu Go 1.25, runtime-ul citește limita de CPU din cgroup pe Linux și o actualizează periodic dacă se schimbă, cu condiția ca GOMAXPROCS să nu fie setat manual.

Pentru diagnostic: GODEBUG=schedtrace=1000 afișează periodic starea scheduler-ului, iar go tool trace arată vizual cum rulează goroutines pe P-uri.

Ce urmărește intervievatorul: Întrebare de senior pentru servicii rulate în Kubernetes. Diferențiază pe cine a investigat latențe reale; menționarea problemei cu limitele CPU în containere e un plus clar.

50 Senior

Descrie pattern-ul pipeline cu fan-out și fan-in. Cum te asiguri că se oprește corect la anulare?

Răspuns scurt: Un pipeline e o serie de etape legate prin canale. Fan-out înseamnă mai mulți worker-i care citesc din același canal, fan-in combinarea mai multor canale într-unul. Oprirea corectă vine din context, verificat la fiecare trimitere.

Exemplu: citești ID-uri, le îmbogățești cu un apel extern lent în paralel și colectezi rezultatele.

GO
func source(ctx context.Context, ids []int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for _, id := range ids {
			select {
			case out <- id:
			case <-ctx.Done():
				return
			}
		}
	}()
	return out
}

func enrich(ctx context.Context, in <-chan int) <-chan Item {
	out := make(chan Item)
	go func() {
		defer close(out)
		for id := range in {
			it := fetchItem(ctx, id)
			select {
			case out <- it:
			case <-ctx.Done():
				return
			}
		}
	}()
	return out
}

func merge(ctx context.Context, chans ...<-chan Item) <-chan Item {
	out := make(chan Item)
	var wg sync.WaitGroup
	for _, c := range chans {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for it := range c {
				select {
				case out <- it:
				case <-ctx.Done():
					return
				}
			}
		}()
	}
	go func() { wg.Wait(); close(out) }()
	return out
}

// fan-out pe 4 worker-i, apoi fan-in
src := source(ctx, ids)
workers := make([]<-chan Item, 4)
for i := range workers {
	workers[i] = enrich(ctx, src)
}
for it := range merge(ctx, workers...) {
	fmt.Println(it)
}

Reguli de siguranță:

  • fiecare etapă își închide canalul de ieșire când termină;
  • fiecare trimitere e într-un select cu ctx.Done(); altfel, dacă consumatorul final se oprește devreme, etapele rămân blocate (goroutine leak);
  • consumatorul care iese devreme apelează cancel(), iar ordinea nu se păstrează.

Backpressure-ul vine natural din canalele unbuffered: o etapă lentă încetinește tot lanțul. Erorile se transmit în Item sau se colectează cu errgroup.

Ce urmărește intervievatorul: Arată stăpânirea concurenței la nivel de design. Se verifică în special anularea la fiecare trimitere, punctul unde majoritatea implementărilor au leak-uri.

net/http, API-uri, gRPC și microservicii

51 Junior

Cum pornești un server HTTP minimal în Go folosind doar biblioteca standard?

Răspuns scurt: Înregistrezi handlere pe un http.ServeMux cu HandleFunc și pornești serverul cu http.ListenAndServe(":8080", mux) sau, mai bine, cu un http.Server configurat explicit. Nu ai nevoie de framework pentru un API simplu.

Varianta minimă:

GO
package main

import (
	"log"
	"net/http"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("ok"))
	})

	log.Println("ascult pe :8080")
	log.Fatal(http.ListenAndServe(":8080", mux))
}

Ce se întâmplă în spate: ListenAndServe deschide un socket TCP, acceptă conexiuni într-o buclă și pornește câte o goroutine per conexiune. Fiecare request ajunge la handler-ul corespunzător rutei. De aceea poți scrie cod blocant (interogare DB, apel HTTP) în handler fără să blochezi alți clienți.

Câteva lucruri pe care un intervievator le apreciază:

  • folosește propriul ServeMux, nu http.DefaultServeMux (http.HandleFunc global), pe care orice pachet importat poate înregistra rute, de exemplu net/http/pprof;
  • ListenAndServe întoarce mereu o eroare non-nil, de aceea e împachetat în log.Fatal;
  • pentru producție creezi un http.Server cu timeout-uri setate și oprire grațioasă, pentru că varianta de mai sus nu are niciun timeout;
  • pattern-ul "GET /health", cu metoda în rută, funcționează din Go 1.22.

Framework-uri ca Gin, Echo sau Chi există și sunt folosite, dar după Go 1.22 multe echipe folosesc doar net/http pentru API-uri REST obișnuite.

Ce urmărește intervievatorul: Verifică dacă știi stdlib-ul, nu doar un framework. Un plus: menționezi o goroutine per conexiune și evitarea DefaultServeMux.

52 Junior

Care e diferența dintre http.Handler și http.HandlerFunc?

Răspuns scurt: http.Handler este interfața cu o singură metodă, ServeHTTP(w, r). http.HandlerFunc este un tip funcție care are această metodă, deci transformă orice funcție cu semnătura potrivită într-un Handler. Este un adaptor.

Definițiile din biblioteca standard:

GO
type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
	f(w, r)
}

Este un exemplu frumos de cum poți atașa metode unui tip funcție în Go.

Când folosești fiecare variantă:

  • Struct care implementează Handler, când handler-ul are dependențe:
GO
type OrderHandler struct {
	svc *orders.Service
	log *slog.Logger
}

func (h *OrderHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// folosește h.svc
}

mux.Handle("GET /orders/{id}", &OrderHandler{svc: svc, log: logger})

În practică, mai des struct-ul are mai multe metode și le înregistrezi pe fiecare cu mux.HandleFunc("GET /orders/{id}", h.Get), unde h.Get este o method value.

  • HandlerFunc pentru handlere simple și, mai ales, pentru middleware care întoarce un handler nou dintr-un closure.

Ce merită spus despre ResponseWriter: header-ele trebuie setate înainte de WriteHeader sau de primul Write. Primul Write fără WriteHeader trimite automat status 200. Apelul repetat al lui WriteHeader e ignorat și produce un avertisment în log (superfluous response.WriteHeader call), semn că un handler nu a dat return după ce a scris o eroare.

Ce urmărește intervievatorul: Verifică înțelegerea interfețelor aplicate în stdlib. Detaliul despre ordinea header-elor și return după eroare arată experiență practică.

53 Junior

Cum definești rute cu metode HTTP și parametri în cale folosind http.ServeMux din Go 1.22?

Răspuns scurt: Din Go 1.22 pattern-urile din ServeMux acceptă metoda și wildcard-uri: mux.HandleFunc("GET /users/{id}", h). Parametrul se citește cu r.PathValue("id"). Dacă metoda nu se potrivește, serverul răspunde automat cu 405 Method Not Allowed.

Exemplu de API REST:

GO
mux := http.NewServeMux()
mux.HandleFunc("GET /users", listUsers)
mux.HandleFunc("POST /users", createUser)
mux.HandleFunc("GET /users/{id}", getUser)
mux.HandleFunc("DELETE /users/{id}", deleteUser)
mux.HandleFunc("GET /files/{path...}", serveFile) // restul căii

func getUser(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		http.Error(w, "id invalid", http.StatusBadRequest)
		return
	}
	// ...
}

Reguli de potrivire:

  • un pattern care se termină în / (de exemplu /static/) potrivește tot subarborele; {$} la final (/{$}) potrivește exact calea;
  • dacă mai multe pattern-uri se potrivesc, câștigă cel mai specific: /users/me are prioritate față de /users/{id}; dacă două pattern-uri sunt la fel de specifice și în conflict, înregistrarea face panic;
  • GET acceptă implicit și HEAD;
  • valorile PathValue sunt deja decodate din URL, dar rămân string-uri, deci le validezi și le convertești.

Query string-ul nu face parte din rută: îl citești cu r.URL.Query().Get("page").

Înainte de 1.22, ServeMux știa doar prefixe de cale, așa că echipele foloseau router-e externe ca gorilla/mux sau chi. Acestea rămân utile pentru grupuri de rute cu middleware diferit, dar pentru multe servicii stdlib-ul e acum suficient. Comportamentul nou depinde de directiva go 1.22 din go.mod.

Ce urmărește intervievatorul: Arată că ești la zi cu Go modern. Mulți candidați cunosc doar Gin și nu știu că stdlib-ul face acum routing cu metode și parametri.

54 Junior

Cum citești un body JSON dintr-un request și cum trimiți un răspuns JSON corect?

Răspuns scurt: Decodezi cu json.NewDecoder(r.Body).Decode(&req), limitând dimensiunea cu http.MaxBytesReader, validezi câmpurile, apoi răspunzi setând Content-Type: application/json, status code-ul și scriind cu json.NewEncoder(w).Encode(resp).

Un handler de creare, cu tratarea erorilor:

GO
type CreateUserRequest struct {
	Email string `json:"email"`
	Name  string `json:"name"`
}

func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
	r.Body = http.MaxBytesReader(w, r.Body, 1<<20) // max 1 MB
	dec := json.NewDecoder(r.Body)
	dec.DisallowUnknownFields()

	var req CreateUserRequest
	if err := dec.Decode(&req); err != nil {
		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "JSON invalid"})
		return
	}
	if req.Email == "" {
		writeJSON(w, http.StatusUnprocessableEntity, map[string]string{"error": "email obligatoriu"})
		return
	}

	u, err := h.svc.Create(r.Context(), req.Email, req.Name)
	if err != nil {
		writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "eroare internă"})
		return
	}
	writeJSON(w, http.StatusCreated, u)
}

func writeJSON(w http.ResponseWriter, status int, v any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	if err := json.NewEncoder(w).Encode(v); err != nil {
		slog.Error("encode response", "err", err)
	}
}

De ce aceste detalii:

  • fără MaxBytesReader, un client poate trimite un body uriaș și consuma memoria serverului;
  • DisallowUnknownFields prinde greșeli de scriere ale clientului (emial), care altfel ar fi ignorate silențios;
  • validarea e separată de decodare: JSON-ul poate fi valid sintactic, dar incomplet;
  • header-ul se setează înainte de WriteHeader; după aceea modificările nu mai au efect;
  • return după fiecare răspuns de eroare, ca să nu scrii de două ori.

Serverul închide singur r.Body după handler. Pe partea de client HTTP însă, resp.Body.Close() e obligatoriu.

Ce urmărește intervievatorul: Este codul pe care îl scrii zilnic. Intervievatorul urmărește limitarea body-ului, validarea și return după erori.

55 Junior

Ce este un middleware în Go și cum scrii unul care măsoară durata fiecărui request?

Răspuns scurt: Un middleware este o funcție care primește un http.Handler și întoarce altul, adăugând comportament înainte și după apelul handler-ului original: logare, autentificare, recover, CORS. Se compun prin împachetare, iar ordinea împachetării contează.

Middleware de logare cu durată și status code:

GO
type statusRecorder struct {
	http.ResponseWriter
	status int
}

func (r *statusRecorder) WriteHeader(code int) {
	r.status = code
	r.ResponseWriter.WriteHeader(code)
}

func Logging(log *slog.Logger) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			start := time.Now()
			rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
			next.ServeHTTP(rec, r)
			log.Info("http",
				"method", r.Method,
				"path", r.URL.Path,
				"status", rec.status,
				"duration", time.Since(start))
		})
	}
}

handler := Recover(Logging(logger)(mux))

Ce merită explicat:

  • ResponseWriter nu expune status-ul scris, de aceea îl împachetăm într-un struct care îl reține; embedding-ul păstrează celelalte metode;
  • dacă handler-ul nu apelează explicit WriteHeader, status-ul implicit e 200, de aici valoarea inițială;
  • ordinea: în Recover(Logging(mux)), Recover e cel mai exterior, deci prinde și panicile din logging;
  • un middleware de autentificare poate opri lanțul: nu apelează next și răspunde direct cu 401.

Capcană la împachetarea ResponseWriter: pierzi interfețe opționale precum http.Flusher, folosite la streaming și server-sent events. Din Go 1.20 există http.NewResponseController, care găsește metodele originale dacă wrapper-ul implementează Unwrap() http.ResponseWriter.

Pentru a transmite date către handlere (utilizatorul autentificat, request ID) se folosește r.WithContext(context.WithValue(...)).

Ce urmărește intervievatorul: Verifică compoziția funcțiilor și înțelegerea ResponseWriter. Detaliul cu status recorder-ul arată că ai scris un middleware real.

56 Junior

Ce coduri de status HTTP folosești pentru un API REST și cum alegi metoda potrivită (GET, POST, PUT, PATCH, DELETE)?

Răspuns scurt: Metodele exprimă intenția: GET citește, POST creează, PUT înlocuiește resursa, PATCH o modifică parțial, DELETE o șterge. Codurile semnalează rezultatul: 2xx succes, 4xx greșeala clientului, 5xx eroarea serverului. GET, PUT și DELETE trebuie să fie idempotente.

Mapare uzuală pentru o resursă /orders:

  • GET /orders → 200 cu lista; GET /orders/42 → 200 sau 404;
  • POST /orders → 201 Created, cu header Location: /orders/43 și resursa în body;
  • PUT /orders/42 → 200 sau 204; înlocuiește integral resursa;
  • PATCH /orders/42 → 200; modifică doar câmpurile trimise;
  • DELETE /orders/42 → 204 No Content.

Coduri de eroare pe care merită să le folosești corect:

  • 400 Bad Request: JSON invalid, parametri greșiți;
  • 401 Unauthorized: lipsește autentificarea sau token-ul e invalid;
  • 403 Forbidden: autentificat, dar fără drept;
  • 404 Not Found;
  • 409 Conflict: email deja folosit, versiune învechită;
  • 422 Unprocessable Content: format corect, dar validare de business eșuată;
  • 429 Too Many Requests, cu Retry-After;
  • 500 pentru erori neașteptate, 502/503/504 pentru dependențe căzute sau timeout.

Idempotent înseamnă că repetarea cererii are același efect ca o singură cerere. Contează pentru retry-uri: un client sau un load balancer poate repeta un PUT în siguranță, dar repetarea unui POST poate crea două comenzi. De aceea API-urile de plăți acceptă un header Idempotency-Key pentru POST.

În Go, folosește constantele http.StatusCreated și celelalte, nu numere, pentru lizibilitate.

Distincția 4xx/5xx contează operațional: alertele se pun de obicei pe rata de 5xx, iar clienții reîncearcă doar la anumite 5xx și la 429, nu la 400.

Ce urmărește intervievatorul: Verifică designul de API și semantica HTTP. Greșelile tipice: 200 cu {"error": ...} în body sau 500 pentru input invalid.

57 Mid

Ce timeout-uri trebuie configurate pe http.Server și pe http.Client? Ce problemă are http.DefaultClient?

Răspuns scurt: Pe server setezi ReadHeaderTimeout, ReadTimeout, WriteTimeout și IdleTimeout, ca un client lent să nu țină conexiuni deschise la nesfârșit. http.DefaultClient nu are niciun timeout, deci un apel către un serviciu care nu răspunde poate bloca goroutina pentru totdeauna.

Server configurat pentru producție:

GO
srv := &http.Server{
	Addr:              ":8080",
	Handler:           handler,
	ReadHeaderTimeout: 5 * time.Second,
	ReadTimeout:       15 * time.Second,
	WriteTimeout:      30 * time.Second,
	IdleTimeout:       120 * time.Second,
}

Ce protejează fiecare:

  • ReadHeaderTimeout: atacuri de tip Slowloris, în care clientul trimite header-ele foarte încet; go vet/linterii de securitate (gosec) semnalează lipsa lui;
  • ReadTimeout: citirea întregului request, inclusiv body-ul;
  • WriteTimeout: timpul de la sfârșitul citirii header-elor până la terminarea scrierii răspunsului; prea mic strică endpoint-urile de streaming sau download;
  • IdleTimeout: cât stă deschisă o conexiune keep-alive nefolosită.

Pentru limite per rută se folosește http.TimeoutHandler sau un context.WithTimeout în handler.

Clientul:

GO
var client = &http.Client{
	Timeout: 10 * time.Second, // tot request-ul, inclusiv citirea body-ului
}

req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
resp, err := client.Do(req)
if err != nil {
	return err
}
defer resp.Body.Close()

Reguli pentru client:

  • creezi un singur http.Client și îl refolosești; e sigur pentru concurență și ține un pool de conexiuni în Transport;
  • închizi mereu resp.Body și, dacă vrei refolosirea conexiunii, citești body-ul până la capăt;
  • MaxIdleConnsPerHost este implicit 2, puțin pentru un serviciu care face multe apeluri către același host; se mărește în http.Transport;
  • un err == nil nu înseamnă succes: verifici resp.StatusCode.

Ce urmărește intervievatorul: Lipsa timeout-urilor e una dintre cele mai comune cauze de incidente în servicii Go. Se verifică dacă ai trecut printr-o astfel de problemă sau o anticipezi.

58 Mid

Cum implementezi graceful shutdown pentru un server HTTP în Go?

Răspuns scurt: Asculți semnalele SIGINT și SIGTERM cu signal.NotifyContext, pornești serverul într-o goroutine, iar la semnal apelezi srv.Shutdown(ctx) cu un timeout. Shutdown nu mai acceptă conexiuni noi și așteaptă terminarea request-urilor în curs. Apoi închizi resursele, precum pool-ul DB.

De ce contează: la un deploy în Kubernetes sau ECS, containerul vechi primește SIGTERM. Dacă procesul se oprește imediat, request-urile în curs sunt tăiate, iar clienții primesc erori. Orchestratorul așteaptă o perioadă (în Kubernetes implicit 30 de secunde, terminationGracePeriodSeconds) înainte de SIGKILL.

GO
func main() {
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	db := mustOpenDB()
	srv := &http.Server{Addr: ":8080", Handler: newRouter(db), ReadHeaderTimeout: 5 * time.Second}

	go func() {
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Fatalf("server: %v", err)
		}
	}()

	<-ctx.Done()
	log.Println("oprire în curs...")

	shutdownCtx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer cancel()
	if err := srv.Shutdown(shutdownCtx); err != nil {
		log.Printf("shutdown forțat: %v", err)
	}
	db.Close()
}

Detalii importante:

  • ListenAndServe întoarce http.ErrServerClosed imediat după Shutdown; nu e o eroare reală;
  • contextul de shutdown e nou, nu derivat din cel anulat de semnal;
  • Shutdown nu așteaptă conexiunile hijacked (WebSocket); pentru ele folosești srv.RegisterOnShutdown;
  • worker-ii de fundal și consumatorii de coadă trebuie opriți și ei, prin anularea unui context comun și așteptare cu WaitGroup.

Într-un mediu cu load balancer, adesea se marchează întâi serviciul ca „not ready” (readiness probe eșuează), se așteaptă câteva secunde ca LB-ul să nu mai trimită trafic, apoi se apelează Shutdown.

Ce urmărește intervievatorul: Arată că ai rulat servicii în producție, cu deploy-uri fără downtime. Semnal bun: legătura cu SIGTERM din orchestrator și cu readiness.

59 Mid

Ce comunică un handler prin r.Context() și cum transmiți date de request, precum un request ID, prin straturile aplicației?

Răspuns scurt: r.Context() este anulat când clientul închide conexiunea, când request-ul HTTP/2 e anulat sau când ServeHTTP se termină. Îl transmiți mai departe la DB și la alte servicii. Date ca request ID sau utilizatorul autentificat se atașează cu context.WithValue într-un middleware, folosind chei de tip neexportat.

Middleware-ul care generează sau preia request ID-ul:

GO
type ctxKey int

const requestIDKey ctxKey = iota

func RequestID(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		id := r.Header.Get("X-Request-ID")
		if id == "" {
			id = newID()
		}
		w.Header().Set("X-Request-ID", id)
		ctx := context.WithValue(r.Context(), requestIDKey, id)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

func RequestIDFrom(ctx context.Context) string {
	id, _ := ctx.Value(requestIDKey).(string)
	return id
}

De ce cheie de tip propriu: dacă două pachete ar folosi cheia string "request_id", s-ar suprascrie reciproc. Un tip neexportat garantează că doar pachetul tău poate citi sau scrie valoarea. Accesorul tipizat (RequestIDFrom) ascunde type assertion-ul.

Folosire în straturile de jos: request ID-ul ajunge în loguri (cu slog poți scrie un handler care îl extrage automat din context), în header-ul apelurilor către alte servicii și în mesajele de eroare către client.

Ce nu pui în context: dependențe (conexiunea DB, logger-ul principal), parametri obligatorii ai funcției sau configurare. Acestea trebuie să fie vizibile în semnătură, altfel funcția are dependențe ascunse și e greu de testat.

Atenție la munca de fundal pornită dintr-un handler: contextul request-ului se anulează când handler-ul se termină. Dacă trimiți un e-mail asincron, folosește context.WithoutCancel(r.Context()) (Go 1.21), care păstrează valorile dar nu și anularea.

Ce urmărește intervievatorul: Verifică folosirea corectă a contextului și disciplina de a nu-l transforma într-un sac de dependențe. Mulți candidați folosesc chei string.

60 Mid

Ce este gRPC, cum se compară cu REST/JSON și când l-ai alege într-o arhitectură de microservicii?

Răspuns scurt: gRPC este un framework RPC care folosește Protocol Buffers pentru contract și serializare binară, peste HTTP/2. Oferă contracte stricte, cod generat și streaming. E des ales între servicii interne; pentru clienți publici și browsere, REST e mai simplu.

Contractul se scrie într-un fișier .proto:

syntax = "proto3";
package orders.v1;
option go_package = "example.com/orders/gen/ordersv1";

service OrderService {
  rpc GetOrder(GetOrderRequest) returns (Order);
  rpc WatchOrders(WatchRequest) returns (stream Order);
}

message GetOrderRequest { string id = 1; }
message Order { string id = 1; int64 total_cents = 2; string status = 3; }

Din el, protoc cu pluginurile protoc-gen-go și protoc-gen-go-grpc (sau unealta buf) generează struct-uri și interfețe Go. Serverul implementează interfața, clientul primește un stub tipizat:

GO
resp, err := client.GetOrder(ctx, &ordersv1.GetOrderRequest{Id: "42"})
if status.Code(err) == codes.NotFound { /* ... */ }

Avantaje:

  • contract unic, versionat, din care se generează cod în mai multe limbaje;
  • serializare binară mai mică și mai rapidă decât JSON;
  • streaming unidirecțional și bidirecțional pe aceeași conexiune HTTP/2;
  • deadline-urile se propagă prin context între servicii; coduri de eroare standard (codes.NotFound, codes.Unavailable).

Dezavantaje:

  • browserele nu pot vorbi gRPC direct; ai nevoie de gRPC-Web sau de un gateway (de exemplu grpc-gateway) care expune REST;
  • mesajele binare nu se pot inspecta cu curl; folosești unelte ca grpcurl;
  • load balancing-ul e mai delicat: conexiunile HTTP/2 sunt de lungă durată, deci un load balancer L4 trimite tot traficul unui client la aceeași instanță.

Regula de evoluție a contractului: nu refolosi și nu schimba numerele de câmp; adaugă câmpuri noi și marchează-le pe cele scoase ca reserved.

Ce urmărește intervievatorul: Se verifică dacă știi trade-off-urile, nu doar definiția. Semnal bun: menționezi problema de load balancing și regulile de compatibilitate proto.

61 Senior

Cum faci comunicarea între microservicii rezistentă la erori? Vorbește despre retry, backoff, idempotență și circuit breaker.

Răspuns scurt: Fiecare apel are timeout, retry-urile se fac doar pe erori tranzitorii și operații idempotente, cu exponential backoff și jitter. Scrierile folosesc chei de idempotență, iar un circuit breaker oprește temporar apelurile spre o dependență căzută.

Într-un sistem distribuit, rețeaua și dependențele cad regulat, deci designul pornește de la ideea că apelurile vor eșua.

Timeout pe fiecare apel, derivat din contextul request-ului, ca să nu depășești bugetul total de timp.

Retry cu exponential backoff și jitter:

GO
func withRetry(ctx context.Context, attempts int, fn func(context.Context) error) error {
	var err error
	for i := 0; i < attempts; i++ {
		if err = fn(ctx); err == nil || !isTransient(err) {
			return err
		}
		backoff := time.Duration(1<<i) * 100 * time.Millisecond
		sleep := backoff/2 + time.Duration(rand.Int64N(int64(backoff/2)))
		select {
		case <-time.After(sleep):
		case <-ctx.Done():
			return ctx.Err()
		}
	}
	return err
}

Jitter-ul (componenta aleatoare) previne situația în care mii de clienți reîncearcă exact în același moment și lovesc din nou serviciul abia revenit. Reîncerci doar erori tranzitorii: timeout, 503, 429, codes.Unavailable, nu 400 sau 404.

Idempotență: retry-ul unui POST /payments poate dubla o plată dacă primul apel a reușit, dar răspunsul s-a pierdut. Soluția: clientul trimite un Idempotency-Key, iar serverul salvează rezultatul pe acea cheie (cu constrângere de unicitate în DB) și îl întoarce la repetare.

Circuit breaker: după un prag de erori, apelurile eșuează imediat pentru o perioadă, apoi câteva cereri de test verifică revenirea. Protejează atât dependența, cât și propriile goroutines și conexiuni. Există biblioteci precum sony/gobreaker.

Alte unelte: limitarea concurenței către o dependență (bulkhead), fallback-uri (date din cache), iar pentru operații care trebuie să ajungă sigur la destinație, comunicare asincronă printr-o coadă (SQS, Kafka) cu pattern-ul outbox. Atenție la retry-uri pe mai multe niveluri: 3 retry-uri pe 3 straturi înseamnă până la 27 de apeluri.

Ce urmărește intervievatorul: Este o întrebare de design de sisteme pentru senior. Se verifică dacă vezi consecințele retry-urilor (duplicate, amplificare), nu doar mecanismul.

62 Senior

Cum faci un serviciu Go observabil în producție? Vorbește despre logging structurat, metrici și tracing.

Răspuns scurt: Folosești logging structurat cu log/slog (Go 1.21+), cu request ID în fiecare linie, metrici în format Prometheus pentru rate, erori și latențe, și tracing distribuit cu OpenTelemetry, ca să urmărești un request prin toate serviciile. Cele trei se leagă prin trace ID.

Logging structurat: în loc de text liber, perechi cheie-valoare, ușor de filtrat în Loki, CloudWatch sau Elasticsearch:

GO
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
slog.SetDefault(logger)

slog.InfoContext(ctx, "order created", "order_id", o.ID, "total_cents", o.Total)
// {"time":"...","level":"INFO","msg":"order created","order_id":"42","total_cents":1999}

În containere scrii pe stdout, iar platforma colectează logurile. Nu loga date personale sau secrete.

Metrici, cu prometheus/client_golang sau OpenTelemetry metrics. Pentru fiecare endpoint, metoda RED: rate (request-uri pe secundă), erori, durată ca histogramă, pentru percentile p95/p99. Plus metrici de runtime: goroutines, heap, pauze de GC, conexiuni din pool-ul DB (db.Stats()). Atenție la cardinalitate: nu pune ID-uri de utilizator sau căi cu parametri ca label, folosește pattern-ul rutei (/users/{id}), altfel numărul de serii explodează.

Tracing distribuit: OpenTelemetry creează un span pentru fiecare operație, iar contextul de trace se propagă prin header-ul traceparent (standard W3C) către serviciile apelate. Bibliotecile otelhttp și instrumentarea pentru gRPC și database/sql acoperă majoritatea apelurilor. Vezi exact că din 800 ms, 650 ms au fost un query lent în al treilea serviciu.

Legătura dintre ele: pui trace_id în fiecare linie de log și folosești exemplars pe metrici. De la o alertă pe latență ajungi la trace, iar de la trace la logurile exacte.

Completări operaționale: endpoint-uri de health, net/http/pprof expus doar intern pentru profilare la cald și alerte definite pe simptome vizibile pentru utilizator (rata de erori, latență), cu SLO-uri.

Ce urmărește intervievatorul: Diferențiază un senior care a operat servicii de unul care doar le-a scris. Semnal puternic: menționează cardinalitatea metricilor și corelarea prin trace ID.

Testare, profilare și unelte

63 Junior

Cum scrii și rulezi un test unitar în Go?

Răspuns scurt: Creezi un fișier _test.go în același pachet, cu funcții func TestXxx(t *testing.T), și le rulezi cu go test ./.... Raportezi eșecurile cu t.Errorf (continuă testul) sau t.Fatalf (oprește testul). Nu e nevoie de framework extern.

Codul de testat, în price.go:

GO
package cart

func ApplyDiscount(cents int64, percent int) int64 {
	if percent <= 0 || percent > 100 {
		return cents
	}
	return cents - cents*int64(percent)/100
}

Testul, în price_test.go:

GO
package cart

import "testing"

func TestApplyDiscount(t *testing.T) {
	got := ApplyDiscount(10000, 15)
	want := int64(8500)
	if got != want {
		t.Errorf("ApplyDiscount(10000, 15) = %d, vrem %d", got, want)
	}
}

Comenzi utile:

BASH
go test ./...                  # toate pachetele
go test -run TestApplyDiscount -v ./cart
go test -race -cover ./...     # cu race detector și acoperire
go test -count=1 ./...         # fără cache-ul de rezultate

Detalii de știut:

  • fișierele _test.go nu intră în binarul de producție;
  • un test în package cart vede și identificatorii neexportați; un test în package cart_test (black-box) vede doar API-ul public, ceea ce verifică pachetul cum îl folosește un client;
  • t.Helper() într-o funcție ajutătoare face ca eroarea să indice linia din test, nu din helper;
  • t.Cleanup(func(){...}) rulează curățenia la finalul testului;
  • t.Parallel() permite rularea în paralel cu alte teste marcate la fel;
  • mesajul de eroare bun conține input-ul, rezultatul obținut și cel așteptat.

Biblioteci ca testify sunt populare pentru aserțiuni mai scurte, dar mulți preferă stdlib-ul simplu.

Ce urmărește intervievatorul: Verifică faptul că testarea face parte din rutina ta. Semnal bun: rulezi -race și știi diferența între testele white-box și black-box.

64 Junior

Ce sunt table-driven tests și de ce sunt atât de folosite în Go?

Răspuns scurt: Un table-driven test definește cazurile de test ca un slice de struct-uri, cu input și rezultat așteptat, și le parcurge într-o buclă, rulând fiecare caz ca subtest cu t.Run. Adăugarea unui caz nou devine o singură linie, iar eșecurile se văd per caz.

Exemplu pentru o funcție care validează un cod poștal românesc (6 cifre):

GO
func TestValidPostalCode(t *testing.T) {
	tests := []struct {
		name  string
		input string
		want  bool
	}{
		{"valid", "400001", true},
		{"prea scurt", "40001", false},
		{"cu litere", "40A001", false},
		{"gol", "", false},
		{"spații", " 400001", false},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			if got := ValidPostalCode(tc.input); got != tc.want {
				t.Errorf("ValidPostalCode(%q) = %v, vrem %v", tc.input, got, tc.want)
			}
		})
	}
}

Avantaje:

  • cazurile limită sunt vizibile dintr-o privire; un reviewer vede imediat ce lipsește (de exemplu un input Unicode);
  • subtestele au nume în output (TestValidPostalCode/cu_litere) și pot fi rulate individual: go test -run 'TestValidPostalCode/gol';
  • un caz eșuat nu le oprește pe celelalte, chiar dacă folosește t.Fatalf, pentru că fiecare subtest are propriul t;
  • logica de verificare e scrisă o singură dată.

Variații utile: câmp wantErr bool pentru funcții care întorc erori, sau un map în loc de slice (ordinea de rulare devine aleatoare, ceea ce poate scoate la iveală dependențe ascunse între cazuri).

Cu t.Parallel() în interiorul subtestului, înainte de Go 1.22 trebuia copiată variabila de buclă (tc := tc); cu semantica nouă a buclelor nu mai e necesar.

Când tabelul devine greu de citit (fiecare caz are setup diferit, mock-uri diferite), e semn că ai nevoie de teste separate.

Ce urmărește intervievatorul: Este stilul dominant de testare în Go. Se verifică dacă îl cunoști și știi să gândești cazuri limită, nu doar calea fericită.

65 Junior

Cum testezi un handler HTTP fără să pornești un server real?

Răspuns scurt: Folosești pachetul net/http/httptest: creezi un request cu httptest.NewRequest, un httptest.NewRecorder() pe post de ResponseWriter și apelezi direct handler.ServeHTTP(rec, req). Apoi verifici status code-ul, header-ele și body-ul din recorder.

Exemplu pentru un endpoint care întoarce un utilizator:

GO
func TestGetUser(t *testing.T) {
	store := &fakeStore{users: map[int64]User{7: {ID: 7, Email: "ana@exemplu.ro"}}}
	h := NewHandler(store)

	mux := http.NewServeMux()
	mux.HandleFunc("GET /users/{id}", h.GetUser)

	req := httptest.NewRequest(http.MethodGet, "/users/7", nil)
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("status = %d, vrem 200; body: %s", rec.Code, rec.Body.String())
	}
	var got User
	if err := json.NewDecoder(rec.Body).Decode(&got); err != nil {
		t.Fatal(err)
	}
	if got.Email != "ana@exemplu.ro" {
		t.Errorf("email = %q", got.Email)
	}
}

De observat: testul trece prin mux, nu apelează direct h.GetUser, pentru că r.PathValue("id") e populat doar de router. Alternativ, setezi manual valoarea cu req.SetPathValue("id", "7") (Go 1.22+).

Pentru partea de client HTTP (codul tău care apelează un API extern), httptest.NewServer pornește un server real pe un port local:

GO
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusServiceUnavailable)
}))
defer srv.Close()

client := NewPaymentsClient(srv.URL)
_, err := client.Charge(ctx, 100)
// verifici că eroarea e tratată ca tranzitorie

Astfel testezi retry-uri, timeout-uri și parsarea răspunsurilor fără dependențe externe. Merită acoperite și cazurile de eroare: body invalid, 404, 500, nu doar succesul.

Ce urmărește intervievatorul: Verifică testarea practică a codului HTTP. Detaliul cu PathValue, populat doar de router, arată că ai scris efectiv astfel de teste.

66 Junior

Ce unelte standard de calitate a codului folosești într-un proiect Go (gofmt, go vet, linters)?

Răspuns scurt: gofmt (sau goimports) formatează codul într-un stil unic, go vet găsește greșeli suspecte pe care compilatorul le acceptă, iar golangci-lint rulează zeci de linteri, ca staticcheck și errcheck. Toate se rulează în CI, iar codul neformatat sau cu avertismente nu se integrează.

Ce face fiecare:

  • gofmt -l . listează fișierele neformatate; gofmt -w le rescrie. În Go nu există dezbateri despre stil: formatul e unic. goimports face același lucru și adaugă sau elimină importurile.
  • go vet ./... detectează greșeli reale: format greșit în Printf (%d cu un string), copierea unui sync.Mutex, cancel de context neapelat, struct tags greșite, cod de neatins. O parte din analize rulează automat la go test.
  • staticcheck găsește bug-uri și cod învechit: valori calculate și neutilizate, API-uri depreciate, comparații mereu adevărate.
  • golangci-lint agregă linteri, configurați într-un .golangci.yml. Des activați: errcheck (erori ignorate), govet, staticcheck, ineffassign, gosec (probleme de securitate), bodyclose (body-uri HTTP neînchise).
  • govulncheck verifică dacă folosești funcții vulnerabile din dependențe, pe baza bazei de date Go a vulnerabilităților; raportează doar ce e efectiv apelat din cod.

Un pas tipic de CI:

BASH
test -z "$(gofmt -l .)"
go vet ./...
golangci-lint run
go test -race -count=1 ./...
govulncheck ./...

Plus go mod tidy urmat de verificarea că go.mod și go.sum nu s-au schimbat, ca să prinzi dependențe neactualizate.

În editor, gopls (language server-ul oficial) arată aceleași avertismente în timp ce scrii. Valoarea reală a uneltelor vine din automatizare: când rulează la fiecare pull request, review-ul se poate concentra pe logică, nu pe formă.

Ce urmărește intervievatorul: Verifică dacă ai lucrat într-un proiect cu standarde și CI. Un junior care știe de go vet și errcheck dă semnalul că scrie cod atent.

67 Mid

Cum faci mocking în Go pentru dependențe precum baza de date sau un API extern?

Răspuns scurt: Definești o interfață mică pentru dependență, la consumator, și dai în teste o implementare falsă, scrisă manual sau generată (mockery, gomock). Pentru accesul la date, testele de integrare cu o bază reală în container sunt adesea mai valoroase.

Serviciul depinde de o interfață, nu de implementarea PostgreSQL:

GO
type UserStore interface {
	ByEmail(ctx context.Context, email string) (User, error)
	Create(ctx context.Context, u User) error
}

type Service struct{ store UserStore }

func (s *Service) Register(ctx context.Context, email string) error {
	_, err := s.store.ByEmail(ctx, email)
	if err == nil {
		return ErrEmailTaken
	}
	if !errors.Is(err, ErrNotFound) {
		return err
	}
	return s.store.Create(ctx, User{Email: email})
}

Un fake scris manual, simplu și lizibil:

GO
type fakeStore struct {
	users   map[string]User
	created []User
	err     error
}

func (f *fakeStore) ByEmail(_ context.Context, e string) (User, error) {
	if f.err != nil {
		return User{}, f.err
	}
	u, ok := f.users[e]
	if !ok {
		return User{}, ErrNotFound
	}
	return u, nil
}

func (f *fakeStore) Create(_ context.Context, u User) error {
	f.created = append(f.created, u)
	return nil
}

func TestRegisterTaken(t *testing.T) {
	s := &Service{store: &fakeStore{users: map[string]User{"a@x.ro": {}}}}
	if err := s.Register(context.Background(), "a@x.ro"); !errors.Is(err, ErrEmailTaken) {
		t.Fatalf("err = %v", err)
	}
}

Fake vs mock: un fake are comportament real simplificat (un map în loc de tabel); un mock generat verifică ce apeluri s-au făcut și cu ce argumente. Mock-urile stricte fac testele fragile, care se strică la orice refactorizare, chiar dacă comportamentul e corect.

Pentru stratul de date, mock-ul nu verifică dacă SQL-ul e corect. Acolo merită teste de integrare cu Testcontainers for Go sau un PostgreSQL pornit în CI cu Docker Compose. Pentru timp, injectează un ceas (func() time.Time) în loc să folosești direct time.Now().

Ce urmărește intervievatorul: Verifică designul testabil și judecata asupra tipului de test. Semnal bun: știi că mock-urile pentru SQL nu dovedesc că query-ul funcționează.

68 Mid

Cum scrii un benchmark în Go și cum interpretezi rezultatul?

Răspuns scurt: Scrii o funcție func BenchmarkXxx(b *testing.B) care rulează codul într-o buclă, cu for b.Loop() din Go 1.24 sau for i := 0; i < b.N; i++ în versiunile mai vechi. O rulezi cu go test -bench=. -benchmem, care raportează timpul și alocările per operație.

Comparăm două moduri de a construi un string:

GO
func BenchmarkConcat(b *testing.B) {
	parts := strings.Fields("a b c d e f g h i j")
	for b.Loop() {
		s := ""
		for _, p := range parts {
			s += p
		}
		_ = s
	}
}

func BenchmarkBuilder(b *testing.B) {
	parts := strings.Fields("a b c d e f g h i j")
	for b.Loop() {
		var sb strings.Builder
		for _, p := range parts {
			sb.WriteString(p)
		}
		_ = sb.String()
	}
}
BASH
go test -bench=. -benchmem -count=10 ./... > new.txt

Output-ul arată, pentru fiecare benchmark, numărul de iterații, ns/op (timp per operație), B/op (bytes alocați) și allocs/op. Adesea alocările explică diferența de timp.

b.Loop() (Go 1.24) are avantaje față de b.N: setup-ul dinaintea buclei rulează o singură dată, iar compilatorul nu poate elimina codul din buclă ca fiind inutil. Cu b.N, setup-ul costisitor trebuie exclus cu b.ResetTimer(), iar rezultatul trebuie atribuit unei variabile globale ca să nu fie optimizat.

Reguli pentru rezultate credibile:

  • rulezi de mai multe ori (-count=10) și compari cu benchstat (golang.org/x/perf/cmd/benchstat), care spune dacă diferența e semnificativă statistic;
  • rulezi pe o mașină liniștită, nu pe laptop în timp ce compilezi altceva;
  • benchmark-ul trebuie să reflecte date realiste; un input de 10 elemente poate da concluzii opuse față de 10.000.

Benchmark-ul confirmă o ipoteză. Ca să afli *unde* se pierde timpul, folosești profilul: go test -bench=. -cpuprofile cpu.out.

Ce urmărește intervievatorul: Verifică dacă iei decizii de performanță pe baza măsurătorilor. Menționarea lui benchstat sau b.Loop arată experiență reală.

69 Mid

Ce este fuzzing-ul în Go și când îl folosești?

Răspuns scurt: Fuzzing-ul, integrat în go test din Go 1.18, generează automat input-uri variate pornind de la exemple date și caută valori care provoacă panic sau încalcă o proprietate verificată de test. E util pentru cod care parsează input neîncrezut: parsere, decodoare, validatoare.

Un fuzz test are prefixul Fuzz și primește *testing.F:

GO
func FuzzParseAmount(f *testing.F) {
	f.Add("12.50")
	f.Add("0")
	f.Add("-3,2")

	f.Fuzz(func(t *testing.T, s string) {
		cents, err := ParseAmount(s)
		if err != nil {
			return // input invalid, acceptabil
		}
		// proprietate: formatarea și parsarea înapoi dau aceeași valoare
		back, err := ParseAmount(FormatAmount(cents))
		if err != nil || back != cents {
			t.Fatalf("round-trip eșuat pentru %q: %d -> %d (%v)", s, cents, back, err)
		}
	})
}

Rulare:

BASH
go test -fuzz=FuzzParseAmount -fuzztime=60s ./money

Cum funcționează: fuzzer-ul pornește de la corpus-ul inițial (f.Add), mută input-urile (inserează, șterge, combină bytes) și folosește informații de acoperire a codului ca să prefere input-urile care ating ramuri noi. Când găsește un caz care eșuează, îl salvează în testdata/fuzz/FuzzParseAmount/ și de atunci acel caz rulează la fiecare go test obișnuit, ca test de regresie.

Ce proprietăți verifici, pentru că rareori știi rezultatul exact:

  • funcția nu face panic pe niciun input;
  • round-trip: decode(encode(x)) == x;
  • invariante: rezultatul e mereu pozitiv, lungimea nu crește;
  • comparație cu o implementare de referință mai lentă.

Unde e valoros: parsarea de formate (CSV, JSON custom, protocoale), validarea input-ului de la utilizatori, cod care lucrează cu Unicode. Găsește des cazuri la care nu te-ai gândi: string-uri cu bytes UTF-8 invalizi, numere uriașe, input gol.

Limitări: tipurile de argumente acceptate sunt de bază (string, []byte, numere, bool), iar fuzzing-ul rulează pe un singur pachet o dată.

Ce urmărește intervievatorul: Arată cunoașterea uneltelor moderne din stdlib. Se verifică în special dacă știi să formulezi proprietăți, nu doar să pornești fuzzer-ul.

70 Senior

Un serviciu Go a devenit lent și consumă tot mai multă memorie în producție. Cum ai depana problema?

Răspuns scurt: Pornesc de la metrici, ca să văd când a început și ce corelează. Apoi iau profiluri pprof (heap, CPU, goroutine) de la instanța afectată, găsesc locul din cod, reproduc într-un test sau benchmark, repar și verific pe aceleași metrici.

Pașii concreți:

1. Metrici și context. Creșterea e graduală (leak) sau bruscă (după un deploy, un trafic nou)? Numărul de goroutines crește și el? Latența crește la toate endpoint-urile sau la unul? GC-ul rulează mai des? Răspunsurile restrâng ipotezele.

2. Profilare la cald. Cu net/http/pprof expus pe un port intern:

GO
import _ "net/http/pprof"

go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()
BASH
go tool pprof -http=:8081 http://localhost:6060/debug/pprof/heap
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30   # CPU
curl -s localhost:6060/debug/pprof/goroutine?debug=1 | head -50

3. Interpretare.

  • în profilul heap, inuse_space arată ce ține memoria acum, iar alloc_space ce se alocă mult; comparația a două profiluri (-diff_base) arată ce a crescut;
  • profilul de goroutines arată mii de goroutines blocate pe aceeași linie: leak de canal sau apeluri fără timeout;
  • profilul CPU arată funcțiile fierbinți: serializare JSON, regex compilat la fiecare request, GC mult din cauza alocărilor.

Cauze pe care le-am căuta: cache fără limită sau fără expirare, sub-slice care ține în viață un buffer mare, goroutines agățate, resp.Body neînchis, map global care doar crește, pool DB epuizat (db.Stats().WaitCount).

4. Reproducere și reparație: un test care demonstrează problema (de exemplu cu goleak) sau un benchmark cu -benchmem, apoi fix-ul și verificarea în producție pe aceleași grafice.

Pentru latențe fără CPU mare, go tool trace arată blocări, contention pe mutex (profilurile mutex și block, care trebuie activate) și pauze. În containere, verific și GOMEMLIMIT față de limita de memorie și throttling-ul de CPU.

Ce urmărește intervievatorul: Este o întrebare de depanare reală, unde contează metoda. Un senior bun pornește de la date, nu de la ghicit, și știe ce profil răspunde la ce întrebare.

Baze de date și SQL

71 Junior

Cum te conectezi la o bază de date din Go cu database/sql? Ce face de fapt sql.Open?

Răspuns scurt: Imporți un driver (de exemplu pgx pentru PostgreSQL), apelezi sql.Open(driver, dsn) și verifici conexiunea cu db.PingContext. sql.Open nu deschide nicio conexiune: creează un *sql.DB, care este un pool de conexiuni gestionat automat, sigur pentru concurență, creat o singură dată per aplicație.

Inițializare tipică:

GO
import (
	"context"
	"database/sql"
	"time"

	_ "github.com/jackc/pgx/v5/stdlib"
)

func openDB(ctx context.Context, dsn string) (*sql.DB, error) {
	db, err := sql.Open("pgx", dsn)
	if err != nil {
		return nil, err // doar DSN invalid sau driver lipsă
	}
	db.SetMaxOpenConns(25)
	db.SetMaxIdleConns(25)
	db.SetConnMaxLifetime(30 * time.Minute)

	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()
	if err := db.PingContext(ctx); err != nil {
		db.Close()
		return nil, err
	}
	return db, nil
}

Ce trebuie să știi:

  • sql.Open validează doar argumentele. Fără Ping, o parolă greșită apare abia la primul query, eventual în producție;
  • *sql.DB nu este o conexiune, ci un pool. Îl creezi o dată la pornire, îl dai mai departe prin dependențe și îl închizi la oprirea aplicației. Deschiderea unui sql.DB per request epuizează rapid conexiunile bazei de date;
  • fiecare query ia o conexiune din pool și o returnează; rows.Close() e cel care o eliberează la citiri cu mai multe rânduri;
  • folosește variantele cu context (QueryContext, ExecContext, QueryRowContext), ca timeout-ul request-ului să oprească și interogarea.

Alternative populare: pgx folosit direct (prin pgxpool), cu performanță mai bună și tipuri specifice PostgreSQL; sqlx pentru scanare în struct-uri; sqlc, care generează cod Go tipizat din fișiere SQL. ORM-uri precum GORM există, dar multe echipe Go preferă SQL explicit.

Ce urmărește intervievatorul: Verifică înțelegerea pool-ului, o sursă frecventă de incidente. Greșeala clasică este sql.Open în fiecare handler.

72 Junior

Ce este SQL injection și cum îl previi în Go?

Răspuns scurt: SQL injection apare când input-ul utilizatorului e concatenat în textul query-ului și ajunge interpretat ca SQL. Îl previi cu query-uri parametrizate ($1 în PostgreSQL, ? în MySQL), unde valorile sunt trimise separat de comandă și nu pot schimba structura ei.

Cod vulnerabil:

GO
q := "SELECT id, email FROM users WHERE email = '" + email + "'"
rows, err := db.QueryContext(ctx, q)

Dacă email este ' OR '1'='1, query-ul devine ... WHERE email = '' OR '1'='1' și întoarce toți utilizatorii. Cu alte input-uri se pot citi alte tabele sau șterge date.

Cod corect:

GO
row := db.QueryRowContext(ctx,
	`SELECT id, email FROM users WHERE email = $1`, email)

Driverul trimite query-ul și parametrii separat către server (sau îi escapează corect), deci valoarea e tratată mereu ca dată, niciodată ca cod. Același lucru e valabil pentru ExecContext la INSERT, UPDATE, DELETE.

Cazuri în care parametrii nu ajută și trebuie să fii atent:

  • numele de coloane sau tabele nu pot fi parametri. Pentru sortare dinamică folosești o listă albă:
GO
allowed := map[string]string{"date": "created_at", "total": "total_cents"}
col, ok := allowed[r.URL.Query().Get("sort")]
if !ok {
	col = "created_at"
}
q := "SELECT id FROM orders ORDER BY " + col
  • fmt.Sprintf cu %s în SQL este același lucru ca o concatenare; linter-ul gosec îl semnalează;
  • LIKE: parametrul e sigur, dar caracterele % și _ din input au în continuare sens special, deci le escapezi dacă vrei căutare literală;
  • listele IN: în PostgreSQL folosești = ANY($1) cu un array, în loc să construiești manual IN (...).

Ca apărare suplimentară, utilizatorul bazei de date al aplicației ar trebui să aibă doar drepturile necesare, nu drepturi de administrator.

Ce urmărește intervievatorul: Este o întrebare de securitate obligatorie. Se verifică în special cazul numelor de coloane dinamice, unde mulți candidați rămân vulnerabili.

73 Junior

Care este diferența dintre INNER JOIN și LEFT JOIN? Dă un exemplu din backend.

Răspuns scurt: INNER JOIN întoarce doar rândurile care au corespondent în ambele tabele. LEFT JOIN întoarce toate rândurile din tabelul din stânga, iar unde nu există corespondent în dreapta, coloanele acestuia sunt NULL. Alegerea depinde dacă vrei să păstrezi și înregistrările fără pereche.

Tabele: customers(id, name) și orders(id, customer_id, total_cents).

Toți clienții care au comenzi, cu fiecare comandă:

SQL
SELECT c.name, o.id, o.total_cents
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id;

Toți clienții, cu numărul de comenzi, inclusiv cei fără comenzi:

SQL
SELECT c.id, c.name, COUNT(o.id) AS orders_count
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.id, c.name;

COUNT(o.id) numără doar valorile non-NULL, deci clienții fără comenzi primesc 0. COUNT(*) ar fi dat 1 pentru ei, o greșeală frecventă.

Clienții care nu au plasat nicio comandă (anti-join):

SQL
SELECT c.id, c.name
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.id IS NULL;

Capcană importantă: o condiție pe tabelul din dreapta pusă în WHERE transformă de fapt un LEFT JOIN într-un INNER JOIN:

SQL
-- pierde clienții fără comenzi în 2026
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.created_at >= '2026-01-01'

-- corect: condiția în ON
LEFT JOIN orders o ON o.customer_id = c.id AND o.created_at >= '2026-01-01'

În Go, coloanele care pot fi NULL după un LEFT JOIN trebuie scanate în tipuri care acceptă NULL (sql.NullInt64, pointeri), altfel Scan întoarce eroare. Mai există RIGHT JOIN (simetricul) și FULL OUTER JOIN, folosite mai rar.

Ce urmărește intervievatorul: Este SQL de bază, dar intervievatorul urmărește capcanele: COUNT pe coloana corectă și condiția din WHERE care anulează LEFT JOIN-ul.

74 Junior

Ce este un index într-o bază de date și când merită adăugat?

Răspuns scurt: Un index este o structură separată, de obicei un B-tree, care găsește rapid rândurile după valorile unor coloane, fără parcurgerea tabelului. Merită pe coloanele din WHERE, JOIN și ORDER BY ale tabelelor mari, dar încetinește scrierile.

Fără index, SELECT * FROM orders WHERE customer_id = 42 face un sequential scan: citește fiecare rând. La milioane de rânduri, durează. Cu un index pe customer_id, baza de date caută în B-tree (logaritmic) și citește direct rândurile potrivite.

SQL
CREATE INDEX idx_orders_customer ON orders (customer_id);

Tipuri de index de reținut:

  • index compus: CREATE INDEX ON orders (customer_id, created_at) servește interogări pe customer_id sau pe customer_id plus created_at, dar nu pe created_at singur, pentru că ordinea coloanelor contează (regula prefixului din stânga);
  • unic: CREATE UNIQUE INDEX ON users (email) garantează unicitatea; o constrângere UNIQUE sau PRIMARY KEY creează automat un index;
  • parțial (PostgreSQL): CREATE INDEX ON orders (created_at) WHERE status = 'pending' indexează doar subsetul interogat des.

Costuri:

  • fiecare INSERT, UPDATE, DELETE actualizează și indexurile;
  • ocupă spațiu pe disc și în memorie;
  • un index pe o coloană cu foarte puține valori distincte (de exemplu un bool) e rareori folosit.

Când nu se folosește un index existent: funcții aplicate pe coloană (WHERE LOWER(email) = ... fără index pe expresie), LIKE '%text' cu wildcard la început, conversii implicite de tip.

Pentru a verifica, rulezi EXPLAIN ANALYZE pe query și vezi dacă apare Index Scan sau Seq Scan. În PostgreSQL, pe un tabel aflat în producție, folosești CREATE INDEX CONCURRENTLY, ca să nu blochezi scrierile pe durata construirii indexului.

Ce urmărește intervievatorul: Verifică înțelegerea costului și beneficiului, nu doar definiția. Semnal bun: știi de ordinea coloanelor în indexul compus și de EXPLAIN.

75 Mid

Cum lucrezi corect cu tranzacții în Go folosind database/sql?

Răspuns scurt: Pornești tranzacția cu db.BeginTx(ctx, opts), pui imediat defer tx.Rollback(), rulezi toate operațiile pe tx (nu pe db) și la final apelezi tx.Commit(). După un commit reușit, Rollback din defer nu mai are efect, deci curățenia e garantată pe orice cale de eroare.

Exemplu: transfer de credit între două conturi, care trebuie să fie atomic.

GO
func (r *Repo) Transfer(ctx context.Context, from, to int64, cents int64) error {
	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return err
	}
	defer tx.Rollback() // ignorat după Commit reușit (întoarce sql.ErrTxDone)

	var balance int64
	err = tx.QueryRowContext(ctx,
		`SELECT balance_cents FROM accounts WHERE id = $1 FOR UPDATE`, from).Scan(&balance)
	if err != nil {
		return fmt.Errorf("citire sold: %w", err)
	}
	if balance < cents {
		return ErrInsufficientFunds
	}

	if _, err := tx.ExecContext(ctx,
		`UPDATE accounts SET balance_cents = balance_cents - $1 WHERE id = $2`, cents, from); err != nil {
		return err
	}
	if _, err := tx.ExecContext(ctx,
		`UPDATE accounts SET balance_cents = balance_cents + $1 WHERE id = $2`, cents, to); err != nil {
		return err
	}
	return tx.Commit()
}

De ce aceste detalii:

  • defer tx.Rollback() imediat după BeginTx acoperă toate ieșirile timpurii și chiar panicile. Fără el, o tranzacție rămasă deschisă ține o conexiune ocupată și lock-uri în bază;
  • toate operațiile pe tx: un apel accidental pe r.db rulează pe altă conexiune, în afara tranzacției;
  • FOR UPDATE blochează rândul citit până la commit, ca două transferuri simultane să nu citească același sold (problema lost update);
  • dacă contextul e anulat, tranzacția face rollback automat.

Tranzacțiile trebuie să fie scurte, fără apeluri HTTP externe în interior, pentru că țin lock-uri. La erori de serializare sau deadlock raportate de bază, reîncerci tranzacția întreagă.

Ce urmărește intervievatorul: Verifică dacă ai scris cod tranzacțional real. Greșelile tipice: lipsa lui defer Rollback și operații executate pe db în loc de tx.

76 Mid

Cum tratezi valorile NULL din baza de date în Go și ce greșeli apar des la citirea rândurilor cu rows?

Răspuns scurt: Coloanele care pot fi NULL se scanează în sql.NullString, sql.NullInt64, sql.Null[T] (Go 1.22) sau în pointeri; un string simplu dă eroare la NULL. La parcurgerea rândurilor închizi rows cu defer, verifici rows.Err() după buclă și nu ignori eroarea de la Scan.

Scanarea unei coloane nullable:

GO
var (
	id       int64
	phone    sql.NullString
	deletedAt *time.Time
)
err := db.QueryRowContext(ctx,
	`SELECT id, phone, deleted_at FROM users WHERE id = $1`, 7).
	Scan(&id, &phone, &deletedAt)
if errors.Is(err, sql.ErrNoRows) {
	return ErrNotFound
}
if phone.Valid {
	fmt.Println(phone.String)
}

Pointerul e adesea mai comod pentru JSON: nil devine null. sql.Null[T], generic, există din Go 1.22.

Parcurgerea corectă a mai multor rânduri:

GO
rows, err := db.QueryContext(ctx, `SELECT id, email FROM users WHERE active`)
if err != nil {
	return nil, err
}
defer rows.Close()

var users []User
for rows.Next() {
	var u User
	if err := rows.Scan(&u.ID, &u.Email); err != nil {
		return nil, err
	}
	users = append(users, u)
}
if err := rows.Err(); err != nil {
	return nil, err
}
return users, nil

Greșeli frecvente:

  • lipsa lui rows.Close(): conexiunea nu se întoarce în pool; după câteva sute de request-uri, aplicația se blochează așteptând conexiuni;
  • ignorarea lui rows.Err(): dacă rețeaua cade la mijlocul citirii, Next() întoarce false ca la final normal, iar tu returnezi o listă incompletă fără eroare;
  • QueryRow pentru zero rânduri nu dă eroare la apel, ci la Scan (sql.ErrNoRows);
  • Query folosit pentru INSERT/UPDATE fără citirea rezultatelor; se folosește Exec;
  • ordinea și numărul coloanelor din SELECT trebuie să corespundă argumentelor din Scan; SELECT * strică totul când se adaugă o coloană.

Pe partea de schemă, cea mai bună tratare a lui NULL e adesea să nu-l permiți: NOT NULL cu valoare implicită acolo unde are sens.

Ce urmărește intervievatorul: Sunt bug-uri foarte comune în cod Go de producție. Intervievatorul urmărește în special rows.Close și rows.Err, care separă candidații experimentați.

77 Mid

Ce înseamnă ACID și ce probleme previn nivelurile de izolare ale tranzacțiilor?

Răspuns scurt: ACID înseamnă atomicitate, consistență, izolare și durabilitate, garanțiile unei tranzacții. Nivelurile de izolare (Read Committed, Repeatable Read, Serializable) stabilesc cât de mult se văd între ele tranzacțiile concurente și previn, pe rând, citirile murdare, citirile nerepetabile și anomaliile de tip phantom.

Pe scurt:

  • Atomicitate: toate operațiile reușesc sau niciuna; un transfer nu poate debita fără să crediteze;
  • Consistență: tranzacția duce baza dintr-o stare validă în alta, respectând constrângerile (chei străine, CHECK, UNIQUE);
  • Izolare: tranzacțiile concurente nu se influențează în moduri neprevăzute;
  • Durabilitate: după commit, datele supraviețuiesc unui crash (prin write-ahead log).

Anomaliile pe care izolarea le previne:

  • dirty read: citești date scrise de o tranzacție care nu a făcut încă commit;
  • non-repeatable read: citești același rând de două ori în aceeași tranzacție și obții valori diferite;
  • phantom read: același SELECT ... WHERE întoarce rânduri noi la a doua rulare;
  • lost update: două tranzacții citesc aceeași valoare, o modifică și ultima scriere o suprascrie pe prima.

Niveluri standard SQL: Read Uncommitted, Read Committed, Repeatable Read, Serializable. PostgreSQL are implicit Read Committed și nu permite niciodată dirty reads; Repeatable Read în PostgreSQL previne și phantoms (prin snapshot), iar Serializable detectează conflictele și întoarce eroare de serializare (cod 40001), caz în care aplicația trebuie să reîncerce tranzacția. MySQL InnoDB are implicit Repeatable Read.

În Go:

GO
tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})

În practică, pentru majoritatea cazurilor se rămâne la Read Committed și se rezolvă punctual conflictele: SELECT ... FOR UPDATE, update-uri atomice (SET stock = stock - 1 WHERE stock > 0) sau optimistic locking cu o coloană version.

Ce urmărește intervievatorul: Verifică înțelegerea concurenței la nivel de bază de date. Semnal bun: cunoști nivelul implicit al bazei folosite și soluții practice pentru lost update.

78 Mid

Ce este problema N+1 query și cum o detectezi și o repari?

Răspuns scurt: Problema N+1 apare când încarci o listă cu un query, apoi faci câte un query pentru fiecare element. O vezi în tracing sau în numărul de query-uri per request și o repari cu un JOIN sau cu un singur query cu ANY.

Cod tipic cu problema:

GO
orders, _ := repo.RecentOrders(ctx, 50) // 1 query
for i := range orders {
	items, _ := repo.ItemsFor(ctx, orders[i].ID) // încă 50 de query-uri
	orders[i].Items = items
}

Local, cu baza pe aceeași mașină, pare rapid. În producție, fiecare query adaugă latența rețelei, plus o conexiune luată din pool de fiecare dată, iar endpoint-ul ajunge să facă 51 de drumuri dus-întors.

Reparații:

GO
// varianta cu un singur query suplimentar, indiferent de N
ids := make([]int64, len(orders))
for i, o := range orders {
	ids[i] = o.ID
}
rows, err := db.QueryContext(ctx,
	`SELECT order_id, sku, qty FROM order_items WHERE order_id = ANY($1)`, ids)
// grupezi rezultatele într-un map[int64][]Item și le atașezi comenzilor

(Cu driverul pgx, un []int64 se transmite direct ca array PostgreSQL.)

Alternativ, un JOIN între orders și order_items, util când datele asociate sunt puține, pentru că JOIN-ul repetă coloanele comenzii pe fiecare rând de item.

Cum detectezi:

  • tracing-ul arată zeci de span-uri SQL identice într-un singur request;
  • logarea query-urilor lente sau extensia pg_stat_statements arată un query mic, rulat de foarte multe ori;
  • o metrică sau un test care numără query-urile per request.

Unde mai apare: ORM-uri cu lazy loading, resolveri GraphQL (rezolvați cu pattern-ul dataloader) și apeluri HTTP către alte microservicii într-o buclă, care sunt aceeași problemă cu latențe și mai mari. Repararea constă tot în lucru pe loturi: un endpoint care acceptă mai multe ID-uri.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente probleme de performanță în backend. Se verifică dacă ai văzut-o în practică și dacă știi și metoda de detecție, nu doar reparația.

79 Senior

Cum gestionezi migrațiile de schemă și configurarea pool-ului de conexiuni pentru un serviciu Go care rulează în mai multe instanțe?

Răspuns scurt: Migrațiile sunt fișiere SQL versionate, rulate de o unealtă (golang-migrate, goose, Atlas) ca pas separat în pipeline și scrise compatibil cu versiunea anterioară a codului. Pool-ul se dimensionează după limita bazei împărțită la numărul de instanțe.

Migrații. Fiecare schimbare e un fișier cu număr de versiune (0007_add_orders_status.up.sql și eventual .down.sql), în Git, aplicat într-o ordine fixă. Unealta ține un tabel cu versiunea curentă și folosește un lock, ca două instanțe să nu ruleze migrația simultan.

Unde rulează: ca job separat înainte de deploy (un job Kubernetes, un pas în CI/CD sau un task ECS), nu la pornirea fiecărei instanțe, ca să eviți curse și porniri lente.

Regula esențială e compatibilitatea în timpul deploy-ului: într-un rolling update rulează simultan versiunea veche și cea nouă. De aceea schimbările distructive se fac în pași (pattern-ul expand and contract):

  • adaugi coloana nouă, nullable sau cu valoare implicită;
  • deploy cu codul care scrie în ambele coloane;
  • backfill pe loturi mici, nu un singur UPDATE pe milioane de rânduri;
  • deploy cu codul care citește doar din coloana nouă;
  • abia apoi elimini coloana veche.

Pe tabele mari, atenție la operațiile care blochează: CREATE INDEX CONCURRENTLY în PostgreSQL, iar adăugarea unei constrângeri cu NOT VALID urmată de VALIDATE CONSTRAINT.

Pool-ul de conexiuni. PostgreSQL are o limită (max_connections), iar fiecare conexiune consumă memorie pe server. Cu 10 instanțe și SetMaxOpenConns(50) ai până la 500 de conexiuni, plus joburi și migrații.

GO
db.SetMaxOpenConns(20)
db.SetMaxIdleConns(20)
db.SetConnMaxLifetime(30 * time.Minute)
db.SetConnMaxIdleTime(5 * time.Minute)

Urmărești db.Stats(): WaitCount și WaitDuration mari înseamnă pool prea mic sau query-uri lente. Când numărul de instanțe crește mult (autoscaling, Lambda), se introduce un pooler extern: PgBouncer sau, pe AWS, RDS Proxy.

Ce urmărește intervievatorul: Arată experiență cu deploy-uri fără downtime și cu limite reale ale bazei de date. Răspunsul slab rulează migrația la pornirea fiecărei instanțe și redenumește coloane direct.

Git, Linux, Docker și AWS

80 Junior

Care este diferența dintre git merge și git rebase? Când îl folosești pe fiecare?

Răspuns scurt: git merge integrează o ramură prin crearea unui commit de merge, păstrând istoria exact cum a fost. git rebase mută commit-urile tale peste vârful altei ramuri, rescriindu-le, și produce o istorie liniară. Rebase-ul se folosește pe ramurile proprii, nepublicate; ramurile partajate nu se rescriu.

Situație: lucrezi pe feature/payments, iar între timp main a primit commit-uri noi.

Cu merge:

BASH
git switch feature/payments
git merge main

Rezultă un commit de merge cu doi părinți. Nimic nu se rescrie, deci e sigur și pe ramuri partajate, dar istoria devine încâlcită dacă faci asta des.

Cu rebase:

BASH
git switch feature/payments
git fetch origin
git rebase origin/main

Git ia fiecare commit al tău și îl reaplică peste origin/main. Commit-urile primesc hash-uri noi. Istoria arată ca și cum ai fi început lucrul de pe ultima versiune a lui main.

Reguli practice:

  • nu face rebase pe commit-uri pe care le-au preluat alții: le rescrii istoria, iar colegii vor avea conflicte și commit-uri duplicate;
  • după rebase pe o ramură deja urcată, ai nevoie de push forțat; folosește git push --force-with-lease, care refuză suprascrierea dacă între timp altcineva a urcat ceva;
  • git rebase -i permite curățarea commit-urilor înainte de review (unește commit-urile de tip „fix typo”);
  • conflictele la rebase apar per commit; rezolvi, faci git add și git rebase --continue, sau renunți cu git rebase --abort.

Multe echipe aleg o politică la nivel de repository: „squash and merge” sau „rebase and merge” în pull request-uri, pentru un main liniar și ușor de citit cu git log și git bisect. Important la interviu este să arăți că știi riscul rescrierii istoriei partajate.

Ce urmărește intervievatorul: Verifică lucrul în echipă cu Git. Răspunsul care semnalează problema este „rebase e mereu mai bun” fără mențiunea despre ramurile partajate.

81 Junior

Cum rezolvi un conflict de merge în Git și cum arată un flux obișnuit de lucru cu pull request-uri?

Răspuns scurt: Un conflict apare când două ramuri modifică aceleași linii. Combini manual zonele marcate de Git, rulezi testele, apoi git add și finalizezi. Fluxul uzual: ramură din main, commit-uri mici, pull request, review, CI verde, merge.

Cum arată un conflict:

<<<<<<< HEAD
const defaultTimeout = 5 * time.Second
=======
const defaultTimeout = 10 * time.Second
>>>>>>> feature/slow-partners

Pașii:

BASH
git status                      # vezi fișierele în conflict
# editezi fișierul, păstrezi varianta corectă, ștergi marcajele
go build ./... && go test ./... # verifici că totul compilează și trece
git add internal/client/http.go
git commit                      # la merge; la rebase: git rebase --continue

Ce contează la rezolvare: să înțelegi de ce a schimbat fiecare parte. Uneori niciuna dintre variante nu e corectă singură și trebuie combinate. Dacă nu ești sigur, întrebi autorul celeilalte modificări. Pentru fișierele generate (go.sum, cod generat din protobuf) e mai sigur să le regenerezi (go mod tidy, buf generate) decât să le editezi manual. git merge --abort te întoarce la starea dinainte.

Fluxul cu pull request-uri:

  • git switch -c feature/order-export pornind de la un main actualizat;
  • commit-uri mici, cu mesaje clare, la imperativ („Add CSV export for orders”);
  • push și deschiderea pull request-ului, cu descriere: ce, de ce, cum ai testat;
  • CI-ul rulează build, linteri, teste;
  • review de la colegi, cu modificări în commit-uri noi;
  • merge după aprobare, apoi ștergerea ramurii.

Cum reduci conflictele: ramuri de scurtă durată, pull request-uri mici, sincronizare frecventă cu main. Un PR de 2.000 de linii stă zile în review și adună conflicte; unul de 200 de linii intră în aceeași zi.

Ce urmărește intervievatorul: Verifică experiența de lucru în echipă. Intervievatorul vrea să audă că rulezi testele după rezolvare și că înțelegi intenția ambelor modificări.

82 Junior

Un serviciu Go nu răspunde pe un server Linux. Ce comenzi folosești ca să investighezi?

Răspuns scurt: Verific dacă procesul rulează (systemctl status, ps), dacă ascultă pe portul așteptat (ss -tlnp), dacă răspunde local (curl localhost:8080/health), apoi citesc logurile (journalctl -u, docker logs) și verific resursele (df -h, free -m, top). Pornesc din interior spre exterior.

Un traseu ordonat, de la proces spre rețea:

BASH
# 1. Rulează procesul?
systemctl status orders-api
ps aux | grep orders-api

# 2. Ce spun logurile?
journalctl -u orders-api --since "15 min ago" -f
# sau, în container: docker logs --tail 200 orders-api

# 3. Ascultă pe port, și pe ce interfață?
ss -tlnp | grep 8080

# 4. Răspunde local?
curl -v http://localhost:8080/health

# 5. Resurse
df -h        # disc plin: logurile sau fișierele temporare umplu discul
free -m      # memorie
top          # CPU, procese
dmesg -T | grep -i -E "killed process|out of memory"   # OOM killer

Ce caut la fiecare pas:

  • procesul a murit: logul arată ultima eroare sau un panic; dmesg arată dacă l-a oprit OOM killer-ul;
  • procesul rulează, dar nu ascultă: a eșuat la pornire (configurare lipsă, port ocupat; ss -tlnp sau lsof -i :8080 arată cine ține portul);
  • ascultă doar pe 127.0.0.1: e accesibil local, nu din exterior; serverul trebuie să asculte pe :8080 sau 0.0.0.0:8080;
  • local merge, din exterior nu: firewall (ufw status, iptables), security group în cloud sau load balancer configurat greșit;
  • răspunde, dar foarte lent: limite de fișiere deschise (ulimit -n), conexiuni epuizate către baza de date.

Pentru conexiunile spre dependențe: nc -zv db-host 5432 verifică dacă portul bazei e accesibil, iar dig sau nslookup verifică rezolvarea DNS.

La interviu contează metoda: pornești de la ipoteze simple, verifici pe rând și nu repornești serviciul înainte de a salva informațiile necesare diagnosticului.

Ce urmărește intervievatorul: Verifică familiaritatea practică cu Linux și o metodă de depanare. Semnal rău: „repornesc serverul și văd dacă merge”.

83 Junior

Explică permisiunile fișierelor în Linux și diferența dintre semnalele SIGTERM și SIGKILL.

Răspuns scurt: Fiecare fișier are drepturi r, w, x pentru proprietar, grup și ceilalți, schimbate cu chmod și chown. SIGTERM cere procesului să se oprească și poate fi tratat pentru o oprire curată; SIGKILL îl oprește imediat, fără reacție.

Permisiuni. ls -l afișează, de exemplu:

-rwxr-x--- 1 app app 12M oct 31 10:00 orders-api

Primul caracter e tipul (- fișier, d director), apoi trei grupuri de câte trei: proprietarul (rwx), grupul (r-x), ceilalți (---). În notație octală, r=4, w=2, x=1, deci rwxr-x--- este 750.

BASH
chmod 750 orders-api
chmod 600 .env          # secrete: doar proprietarul citește
chown app:app orders-api

Pe un director, x înseamnă dreptul de a intra în el. Principii pentru un serviciu: rulează ca utilizator dedicat, fără privilegii de root; fișierele cu secrete au 600; binarul nu poate fi modificat de utilizatorul care îl rulează.

Semnale.

  • SIGTERM (15) este semnalul implicit al lui kill, cel trimis de systemctl stop și de docker stop. Procesul îl poate prinde și poate face graceful shutdown: termină request-urile în curs, închide conexiunile;
  • SIGKILL (9), trimis cu kill -9, nu poate fi prins sau ignorat. Procesul dispare imediat: request-urile în curs sunt tăiate, fișierele pot rămâne parțial scrise;
  • SIGINT (2) este Ctrl+C în terminal.

docker stop trimite SIGTERM, așteaptă implicit 10 secunde, apoi trimite SIGKILL. În Go, prinzi SIGTERM cu signal.NotifyContext(ctx, syscall.SIGTERM, os.Interrupt).

Un detaliu de container: procesul cu PID 1 nu are comportamentul implicit de terminare la SIGTERM. Dacă aplicația pornește printr-un script shell care nu transmite semnalele, oprirea așteaptă mereu timeout-ul. Folosește forma exec în Dockerfile (ENTRYPOINT ["/app"]).

Ce urmărește intervievatorul: Verifică bazele de Linux, plus legătura cu oprirea grațioasă. Semnal rău: chmod 777 ca soluție la orice problemă de permisiuni.

84 Junior

Care este diferența dintre o imagine Docker și un container?

Răspuns scurt: O imagine este un șablon read-only, format din straturi, care conține sistemul de fișiere și configurarea necesară pentru rularea aplicației. Un container este o instanță în execuție a unei imagini, cu propriul strat de scriere, procese izolate și rețea. Dintr-o imagine pornești oricâte containere.

O analogie utilă pentru programatori: imaginea e ca un binar compilat, containerul e procesul pornit din el.

Imaginea:

  • se construiește dintr-un Dockerfile cu docker build -t orders-api:1.4.0 .;
  • e formată din straturi (layers); fiecare instrucțiune care modifică fișierele (COPY, RUN) adaugă un strat. Straturile sunt cache-uite și partajate între imagini, deci rebuild-urile și download-urile sunt rapide dacă se schimbă doar ultimele straturi;
  • e imuabilă și identificată printr-un digest (sha256:...); tag-ul (:1.4.0, :latest) e doar o etichetă mutabilă;
  • se publică într-un registry: Docker Hub, Amazon ECR, GitHub Container Registry.

Containerul:

BASH
docker run -d --name orders -p 8080:8080 -e DB_URL=... orders-api:1.4.0
docker ps
docker logs -f orders
docker exec -it orders sh   # dacă imaginea are shell
docker stop orders && docker rm orders
  • adaugă un strat subțire de scriere deasupra imaginii; ce scrii acolo se pierde când containerul e șters, de aceea datele persistente merg în volume sau în servicii externe;
  • izolarea vine din funcții ale kernel-ului Linux: namespaces (procese, rețea, sistem de fișiere separate) și cgroups (limite de CPU și memorie);
  • spre deosebire de o mașină virtuală, containerul împarte kernel-ul gazdei, deci pornește în fracțiuni de secundă și consumă puțin în plus față de proces.

Bună practică: în producție referi imaginile după un tag de versiune sau după digest, nu după latest, ca deploy-urile să fie reproductibile și rollback-ul clar.

Ce urmărește intervievatorul: Este întrebarea de bază despre containere. Se verifică modelul mental al straturilor și al stării efemere a containerului.

85 Junior

Cum rulezi local un serviciu Go împreună cu PostgreSQL folosind Docker Compose? Ce sunt volumele și rețelele?

Răspuns scurt: Descrii serviciile într-un compose.yaml (aplicația și baza de date), iar docker compose up le pornește într-o rețea comună, unde se găsesc după numele serviciului. Datele bazei se pun într-un volum, ca să supraviețuiască recreării containerului.

Un fișier tipic:

YAML
services:
  api:
    build: .
    ports:
      - "8080:8080"
    environment:
      DATABASE_URL: postgres://app:secret@db:5432/orders?sslmode=disable
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: orders
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d orders"]
      interval: 2s
      retries: 15

volumes:
  pgdata:
BASH
docker compose up -d --build
docker compose logs -f api
docker compose down        # păstrează volumul
docker compose down -v     # șterge și datele

Concepte:

  • Rețeaua: Compose creează o rețea pentru proiect, cu DNS intern. API-ul se conectează la db:5432, nu la localhost. În interiorul unui container, localhost înseamnă containerul însuși, o confuzie foarte frecventă;
  • Porturi: "8080:8080" publică portul pe mașina gazdă. Baza nu are nevoie de port publicat ca să fie accesibilă API-ului; îl publici doar dacă vrei să te conectezi cu un client de pe laptop;
  • Volume: pgdata e un volum gestionat de Docker; fără el, datele dispar la docker compose down. Există și bind mounts (./migrations:/migrations), care montează un director local, utile în dezvoltare;
  • depends_on cu service_healthy așteaptă ca baza să răspundă efectiv, nu doar să pornească containerul. Chiar și așa, aplicația ar trebui să reîncerce conexiunea la pornire.

Parolele din exemplu sunt doar pentru dezvoltare locală; în producție secretele vin dintr-un secret manager.

Ce urmărește intervievatorul: Verifică experiența practică de dezvoltare locală. Greșeala clasică pe care o caută intervievatorul: conectarea la localhost din interiorul containerului.

86 Junior

Ce sunt IAM users, roles și policies în AWS și ce înseamnă principiul privilegiului minim?

Răspuns scurt: IAM controlează cine poate face ce în AWS. Un user are credențiale permanente, un role oferă credențiale temporare asumate de servicii sau oameni, iar o policy e un JSON cu permisiuni. Privilegiul minim înseamnă doar acțiunile și resursele necesare.

O policy care permite unui serviciu să citească și să scrie doar într-un singur bucket:

JSON
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:PutObject"],
      "Resource": "arn:aws:s3:::facturi-prod/*"
    }
  ]
}

Elementele: Effect (Allow sau Deny), Action (operațiile API), Resource (ARN-ul resursei) și, opțional, Condition. Un Deny explicit câștigă mereu în fața unui Allow, iar implicit totul e interzis.

Roles în loc de chei de acces pentru aplicații:

  • pe EC2, atașezi un instance profile cu un rol;
  • pe ECS, un task role;
  • pe Lambda, un execution role;
  • în EKS, IAM Roles for Service Accounts sau EKS Pod Identity.

SDK-ul AWS pentru Go primește automat credențiale temporare, rotite de AWS. Nu ai chei permanente în cod, în variabile de mediu sau în imaginea Docker, deci nu ai ce să scapi accidental într-un repository public.

Privilegiul minim în practică:

  • fără "Action": "*" sau "Resource": "*" pentru aplicații;
  • roluri separate per serviciu și per mediu (staging nu poate atinge producția);
  • utilizatorii umani se autentifică prin SSO (IAM Identity Center), cu MFA, nu cu chei de lungă durată;
  • contul root nu se folosește pentru lucrul zilnic.

Unelte: IAM Access Analyzer poate genera o policy pe baza activității reale, iar CloudTrail înregistrează cine a apelat ce API, util la depanarea erorilor AccessDenied și la audit.

Ce urmărește intervievatorul: Verifică bazele de securitate în cloud. Semnalul rău: chei de acces AWS puse în cod sau în variabile de mediu pentru o aplicație care rulează pe EC2 sau ECS.

87 Mid

Cum scrii un Dockerfile bun pentru o aplicație Go? Ce este un multi-stage build?

Răspuns scurt: Un multi-stage build compilează aplicația într-o imagine cu toolchain-ul Go, apoi copiază doar binarul într-o imagine finală minimă, precum distroless sau scratch. Rezultatul e o imagine mică, cu mai puține vulnerabilități, fără compilator și fără codul sursă.

Un Dockerfile tipic:

# syntax=docker/dockerfile:1
FROM golang:1.23 AS build
WORKDIR /src

COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/api ./cmd/api

FROM gcr.io/distroless/static-debian12:nonroot
COPY --from=build /out/api /api
USER nonroot:nonroot
EXPOSE 8080
ENTRYPOINT ["/api"]

De ce fiecare detaliu:

  • ordinea COPY: go.mod și go.sum se copiază întâi, apoi go mod download. Stratul cu dependențele rămâne în cache cât timp nu se schimbă dependențele, deci rebuild-urile după modificări de cod sunt rapide;
  • CGO_ENABLED=0 produce un binar static, fără dependențe de biblioteca C a sistemului, necesar pentru scratch sau distroless/static. Dacă folosești pachete care cer cgo, ai nevoie de o imagine de bază cu libc;
  • -trimpath scoate căile locale din binar, iar -ldflags="-s -w" elimină tabelele de simboluri și informațiile de debug, reducând mărimea;
  • imaginea finală: distroless/static conține certificatele CA (necesare pentru HTTPS către alte servicii), date de fus orar și un utilizator non-root, dar nu are shell. scratch e complet goală, deci trebuie să copiezi manual certificatele;
  • USER nonroot: dacă aplicația e compromisă, atacatorul nu are root în container;
  • forma exec a lui ENTRYPOINT face ca binarul să fie PID 1 și să primească direct SIGTERM.

Nu uita un .dockerignore (.git, binare locale, .env), ca să nu copiezi secrete sau fișiere mari în contextul de build. Pentru depanare, distroless are variante :debug cu un shell minimal.

Ce urmărește intervievatorul: Este practică zilnică pentru Go în cloud. Se urmărește înțelegerea cache-ului de straturi, a lui CGO_ENABLED și a securității imaginii finale.

88 Mid

Cum gestionezi configurarea și secretele unui serviciu Go care rulează în mai multe medii (dev, staging, producție)?

Răspuns scurt: Configurarea vine din variabile de mediu (principiul 12-factor), citită și validată o dată la pornire într-un struct tipizat. Secretele nu stau în Git sau în imagine, ci într-un secret manager, de unde sunt injectate la rulare.

Încărcarea configurării la pornire, cu eșec rapid dacă lipsește ceva:

GO
type Config struct {
	Port        string
	DatabaseURL string
	LogLevel    slog.Level
	HTTPTimeout time.Duration
}

func Load() (Config, error) {
	c := Config{
		Port:        getenv("PORT", "8080"),
		DatabaseURL: os.Getenv("DATABASE_URL"),
	}
	if c.DatabaseURL == "" {
		return Config{}, errors.New("DATABASE_URL lipsește")
	}
	d, err := time.ParseDuration(getenv("HTTP_TIMEOUT", "10s"))
	if err != nil {
		return Config{}, fmt.Errorf("HTTP_TIMEOUT invalid: %w", err)
	}
	c.HTTPTimeout = d
	if err := c.LogLevel.UnmarshalText([]byte(getenv("LOG_LEVEL", "INFO"))); err != nil {
		return Config{}, err
	}
	return c, nil
}

func getenv(k, def string) string {
	if v, ok := os.LookupEnv(k); ok {
		return v
	}
	return def
}

De ce așa:

  • aceeași imagine rulează în toate mediile; doar configurarea diferă. Nu construiești imagini separate pentru staging și producție;
  • eșec la pornire: un serviciu care pornește cu o configurare invalidă și cade la primul request e mai greu de depanat decât unul care refuză să pornească, iar orchestratorul oprește rollout-ul;
  • struct tipizat transmis prin dependențe, nu os.Getenv împrăștiat prin cod.

Secretele:

  • în ECS, definiția task-ului poate referi direct un secret din Secrets Manager sau SSM, injectat ca variabilă de mediu la pornire; în Kubernetes, Secrets sau External Secrets Operator;
  • alternativ, aplicația le citește la pornire cu SDK-ul AWS, folosind rolul IAM;
  • nu loga configurarea completă la pornire fără a masca secretele;
  • un fișier .env e potrivit doar pentru dezvoltare locală și se pune în .gitignore.

Biblioteci ca envconfig sau caarlos0/env fac maparea prin struct tags, dacă vrei mai puțin cod.

Ce urmărește intervievatorul: Verifică maturitatea operațională. Semnale proaste: secrete în repository, imagini diferite per mediu sau configurare citită peste tot cu os.Getenv.

89 Mid

Explică un VPC în AWS: subrețele publice și private, security groups și cum ajunge traficul la serviciul tău.

Răspuns scurt: Un VPC este o rețea privată izolată în AWS. Subrețelele publice, cu rută spre Internet Gateway, găzduiesc load balancer-ul; cele private, aplicația și baza de date. Security groups sunt firewall-uri cu stare care permit doar traficul declarat.

O arhitectură tipică pentru un API Go:

  • VPC cu un bloc de adrese, de exemplu 10.0.0.0/16, întins pe două sau trei zone de disponibilitate (AZ) pentru redundanță;
  • subrețele publice (câte una per AZ): Application Load Balancer-ul și NAT Gateway-ul. Tabela lor de rutare trimite 0.0.0.0/0 către Internet Gateway;
  • subrețele private: task-urile ECS sau instanțele EC2 cu aplicația și baza RDS. Nu au IP public. Pentru ieșiri spre internet (API-uri externe, descărcări) trec prin NAT Gateway;
  • VPC endpoints pentru S3, ECR sau Secrets Manager, ca traficul către serviciile AWS să nu treacă prin NAT, ceea ce reduce costul și expunerea.

Fluxul unui request: client → DNS (Route 53) → ALB în subrețeaua publică (terminare TLS) → target group → task-ul Go pe portul 8080 în subrețeaua privată → RDS pe portul 5432.

Security groups sunt stateful (răspunsul la o conexiune permisă trece automat) și pot referi alte security groups în loc de IP-uri:

  • sg-alb: permite 443 din 0.0.0.0/0;
  • sg-app: permite 8080 doar din sg-alb;
  • sg-db: permite 5432 doar din sg-app.

Astfel, chiar dacă cineva află adresa bazei de date, nu se poate conecta din afara aplicației.

Network ACL-urile sunt un al doilea nivel, la nivel de subrețea, fără stare, folosite mai rar.

Probleme de rețea pe care le întâlnești des: timeout la conexiunea spre RDS (security group lipsă), task fără acces la ECR pentru a descărca imaginea (fără NAT sau endpoint), health check-uri ALB eșuate pentru că sg-app nu permite traficul din ALB.

Ce urmărește intervievatorul: Verifică dacă înțelegi rețeaua în care rulează serviciul, nu doar codul. Semnal bun: regulile de security group care referă alte grupuri, nu IP-uri.

90 Mid

Cum lucrezi cu S3 din Go folosind AWS SDK v2? Cum obține SDK-ul credențialele?

Răspuns scurt: Încarci configurarea cu config.LoadDefaultConfig(ctx), creezi un client cu s3.NewFromConfig(cfg) și apelezi operații precum PutObject și GetObject. Credențialele se caută automat într-un lanț: variabile de mediu, fișierele ~/.aws, apoi rolul atașat containerului sau instanței.

Exemplu de încărcare a unei facturi:

GO
import (
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)

func newS3(ctx context.Context) (*s3.Client, error) {
	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("eu-central-1"))
	if err != nil {
		return nil, err
	}
	return s3.NewFromConfig(cfg), nil
}

func uploadInvoice(ctx context.Context, c *s3.Client, id string, pdf io.Reader) error {
	_, err := c.PutObject(ctx, &s3.PutObjectInput{
		Bucket:      aws.String("facturi-prod"),
		Key:         aws.String("invoices/" + id + ".pdf"),
		Body:        pdf,
		ContentType: aws.String("application/pdf"),
	})
	return err
}

Lanțul de credențiale implicit, în ordine aproximativă: variabilele AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY, fișierele de configurare partajate (inclusiv profiluri SSO, pentru dezvoltare locală), apoi credențialele furnizate de mediu: rolul de task ECS, IAM Roles for Service Accounts în EKS, instance profile pe EC2. În producție, nu setezi nimic manual; rolul IAM face totul.

Bune practici:

  • creezi clientul o singură dată și îl refolosești; e sigur pentru concurență;
  • pentru fișiere mari folosești managerul de transfer (pachetul feature/s3/manager), care face upload multipart în paralel;
  • pentru download-uri din browser, nu treci fișierul prin serviciul tău, ci generezi un presigned URL cu s3.NewPresignClient, valabil câteva minute;
  • erorile specifice se verifică cu errors.As, de exemplu *types.NoSuchKey;
  • bucket-urile rămân private (Block Public Access activ), cu criptare implicită.

Pentru teste locale, poți folosi un emulator compatibil S3 (LocalStack, MinIO) setând un endpoint personalizat la crearea clientului.

Ce urmărește intervievatorul: Verifică experiența practică cu cloud-ul. Se urmărește în special înțelegerea lanțului de credențiale și folosirea rolurilor în locul cheilor.

91 Senior

Trebuie să rulezi în AWS un API Go nou. Cum alegi între EC2, ECS cu Fargate, EKS și Lambda?

Răspuns scurt: Depinde de trafic, echipă și costul de operare. Lambda pentru trafic intermitent și evenimente, ECS cu Fargate pentru servicii permanente fără servere de administrat, EKS când ai deja Kubernetes, EC2 când ai nevoie de control total.

Cum aș argumenta la interviu, criteriu cu criteriu:

Lambda

  • plătești per invocare și durată; la trafic zero costul e aproape zero;
  • scalare automată foarte rapidă, fără configurare;
  • Go merge bine: binar compilat, cold start mic; se rulează pe runtime-ul provided.al2023 cu biblioteca aws-lambda-go;
  • limite: durată maximă de 15 minute per invocare, model cerere-răspuns, fără conexiuni de lungă durată; conexiunile la o bază relațională pot exploda la concurență mare, deci ai nevoie de RDS Proxy;
  • ideal pentru webhook-uri, procesare din SQS sau S3, joburi programate.

ECS cu Fargate

  • rulezi imaginea Docker fără să administrezi servere; definești CPU și memorie per task;
  • potrivit pentru un API cu trafic constant, conexiuni persistente, WebSocket sau gRPC;
  • integrare directă cu ALB, autoscaling pe CPU sau număr de request-uri, secrete injectate;
  • pentru o echipă mică, de obicei cel mai bun raport între simplitate și control.

EKS

  • Kubernetes gestionat: ecosistem bogat, portabilitate, aceleași unelte între cloud-uri;
  • cost operațional mare: upgrade-uri de cluster, rețea, observabilitate, oameni care știu Kubernetes;
  • justificat la zeci de servicii sau când organizația are deja platforma.

EC2

  • control total (kernel, disc local, instanțe specializate), dar tu administrezi patch-urile, scalarea și deploy-urile;
  • util pentru sarcini speciale sau când costul la utilizare constantă mare contează mai mult.

Pentru „API nou, echipă mică, trafic necunoscut” aș alege ECS cu Fargate în spatele unui ALB, sau Lambda la trafic intermitent, cu infrastructura ca cod (Terraform, CDK). Dar întâi aș întreba: ce trafic, ce latență, ce stare, ce știe echipa.

Ce urmărește intervievatorul: Este o întrebare de judecată, nu are un singur răspuns corect. Se verifică dacă argumentezi pe criterii (trafic, cost, operare, echipă) și dacă pui întrebări de clarificare.

92 Senior

Ce sunt health checks, liveness și readiness? Cum le implementezi corect într-un serviciu Go din spatele unui load balancer?

Răspuns scurt: Liveness răspunde la întrebarea „procesul funcționează sau trebuie repornit?”, iar readiness la „poate primi trafic acum?”. Load balancer-ul trimite trafic doar instanțelor ready. Liveness trebuie să fie simplu și să nu depindă de servicii externe, altfel o bază lentă repornește toate instanțele simultan.

Două endpoint-uri separate:

GO
type Health struct {
	db       *sql.DB
	shutdown atomic.Bool
}

func (h *Health) Live(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK) // procesul răspunde: e în viață
}

func (h *Health) Ready(w http.ResponseWriter, r *http.Request) {
	if h.shutdown.Load() {
		http.Error(w, "shutting down", http.StatusServiceUnavailable)
		return
	}
	ctx, cancel := context.WithTimeout(r.Context(), 500*time.Millisecond)
	defer cancel()
	if err := h.db.PingContext(ctx); err != nil {
		http.Error(w, "db unavailable", http.StatusServiceUnavailable)
		return
	}
	w.WriteHeader(http.StatusOK)
}

mux.HandleFunc("GET /livez", h.Live)
mux.HandleFunc("GET /readyz", h.Ready)

De ce separarea contează:

  • liveness dependent de baza de date e o greșeală clasică: baza devine lentă, toate verificările eșuează, orchestratorul repornește toate instanțele, iar la pornire fiecare deschide conexiuni noi și agravează problema. Un efect de cascadă pornit de un health check;
  • readiness poate include dependențele critice, cu timeout scurt, ca instanța să fie scoasă temporar din rotație. Chiar și aici trebuie atenție: dacă toate instanțele devin unready din cauza bazei, nu mai servești nimic, nici măcar răspunsuri din cache;
  • la oprire, setezi shutdown pe true la primirea SIGTERM, readiness începe să întoarcă 503, aștepți câteva secunde ca load balancer-ul să scoată instanța, apoi apelezi srv.Shutdown;
  • la pornire, readiness devine ok abia după ce conexiunile și cache-urile sunt pregătite. Kubernetes are și startup probe pentru aplicații care pornesc lent.

Pe AWS, ALB-ul are propriul health check pe target group (cale, interval, praguri), iar ECS poate folosi și health check-ul containerului. Endpoint-urile de health nu se loghează la fiecare apel și nu ar trebui să expună detalii interne publicului.

Ce urmărește intervievatorul: Diferențiază seniorii care au trăit un incident de cascadă. Răspunsul slab pune ping la baza de date în liveness.

93 Senior

Cum ai proiecta un serviciu Go care trebuie să scaleze orizontal în cloud? Ce constrângeri impune scalarea orizontală asupra codului?

Răspuns scurt: Serviciul trebuie să fie stateless: orice instanță servește orice request, iar starea stă în servicii externe (baza de date, Redis, S3, cozi). Adaugi instanțe în spatele unui load balancer, cu autoscaling, și urmărești următoarea limită, de obicei baza de date.

Constrângeri concrete asupra codului:

  • fără stare în memorie care contează: sesiunile utilizatorilor nu stau într-un map local, ci în token-uri semnate (JWT) sau într-un store partajat; altfel, al doilea request al utilizatorului ajunge la altă instanță și „uită” autentificarea;
  • fără fișiere locale persistente: încărcările merg în S3; discul containerului e efemer;
  • cache-ul local e permis doar dacă datele vechi câteva secunde sunt acceptabile, cu TTL; pentru invalidare comună folosești Redis (ElastiCache);
  • joburi programate: un cron intern în fiecare instanță rulează de N ori. Soluții: un singur job extern (EventBridge Scheduler, Kubernetes CronJob), un lock distribuit sau SELECT ... FOR UPDATE SKIP LOCKED pe un tabel de joburi;
  • rate limiting global necesită un contor partajat, nu unul per instanță;
  • idempotența devine obligatorie, pentru că retry-urile load balancer-ului și ale clienților pot ajunge la instanțe diferite.

Arhitectura:

  • ALB → N task-uri ECS/pod-uri, autoscaling după CPU, request-uri per target sau latență;
  • munca grea sau lentă se mută asincron: API-ul pune un mesaj în SQS și răspunde 202, iar worker-i separați, scalați după lungimea cozii, procesează mesajele;
  • baza de date e de obicei limita: pool-uri dimensionate în funcție de numărul de instanțe, replici de citire pentru rapoarte, indexuri, cache pentru citirile fierbinți.

Partea de Go ajută: binarul pornește în sub o secundă și consumă puțină memorie, deci scalarea reacționează rapid. Dar trebuie configurate graceful shutdown și readiness, ca scale-in-ul să nu taie request-uri.

Un senior verifică ipotezele cu teste de încărcare (k6, vegeta) și urmărește ce cedează primul, în loc să presupună.

Ce urmărește intervievatorul: Este o întrebare de system design adaptată rolului. Se verifică dacă vezi efectele concrete ale mai multor instanțe asupra codului, în special joburile și starea locală.

Comportamentale și HR

94 Junior

Povestește-mi despre tine și de ce vrei să lucrezi ca Backend Developer cu Go.

Răspuns scurt: Un răspuns bun durează unul-două minute și leagă ce ai făcut relevant pentru backend, ce te atrage concret la Go și la cloud și de ce te interesează rolul acesta. E o poveste coerentă, nu o recitare a CV-ului.

Structura recomandată este trecut, prezent, viitor:

  • Trecut: de unde vii, pe scurt. Facultate, reconversie din alt domeniu, primele proiecte. Alege doar ce are legătură cu rolul.
  • Prezent: ce știi să faci acum, cu dovezi. Un proiect concret: „am construit un API în Go cu PostgreSQL, rulat în Docker, cu teste și deploy pe AWS”. Detaliile tehnice reale contează mai mult decât adjectivele.
  • Viitor: de ce acest rol. Ce te atrage la Go (simplitatea, concurența, faptul că e folosit în infrastructura cloud) și ce ai înțeles despre produsul sau echipa lor.

Model de răspuns pentru un candidat în reconversie:

„Am lucrat patru ani în logistică, unde am început să automatizez rapoarte cu scripturi. Asta m-a dus spre programare. În ultimul an m-am concentrat pe backend și am ales Go pentru că îmi place că limbajul e mic și explicit, iar concurența e integrată. Proiectul de care sunt cel mai mândru e un serviciu de urmărire a coletelor: API REST cu net/http, PostgreSQL, worker-i care procesează actualizări în paralel, teste table-driven și un pipeline care face deploy pe ECS. Am învățat mult depanând un goroutine leak apărut sub încărcare. Caut un rol în care să lucrez pe servicii reale, cu oameni de la care să învăț, iar faptul că voi construiți platforme de livrare se leagă direct de experiența mea anterioară.”

Ce să eviți:

  • „vreau să lucrez cu Go pentru că se plătește bine”, ca motiv principal;
  • generalități („sunt pasionat, muncitor, învăț repede”) fără exemple;

Ce urmărește intervievatorul: Intervievatorul evaluează comunicarea și motivația reală. Greșeala tipică este un monolog lung despre CV, fără un proiect concret.

95 Junior

Povestește-mi despre un bug greu pe care l-ai rezolvat.

Răspuns scurt: Folosește metoda STAR: situația, sarcina, acțiunile și rezultatul. Accentul cade pe acțiuni, adică pe cum ai gândit: ipoteze, cum le-ai verificat, ce unelte ai folosit. Încheie cu ce ai învățat și ce ai schimbat ca problema să nu se repete.

Structura STAR aplicată:

  • Situație: contextul, pe scurt. Ce sistem, ce simptom.
  • Sarcină: ce aveai tu de făcut.
  • Acțiuni: pașii concreți ai investigației. Asta e partea cea mai importantă.
  • Rezultat: ce s-a reparat, cum ai verificat și ce ai învățat.

Model de răspuns:

„Situație: într-un proiect personal, un serviciu Go care importa fișiere CSV mari funcționa bine local, dar după câteva ore pe server memoria creștea până când containerul era oprit de OOM killer.

Sarcină: să găsesc cauza; nu aveam nicio eroare în loguri.

Acțiuni: am adăugat întâi metrica numărului de goroutines și am văzut că creștea la fiecare import. Am activat net/http/pprof și am luat un profil de goroutines: sute erau blocate la trimiterea pe un canal. Codul pornea un worker per fișier, care trimitea rezultatele pe un canal unbuffered, dar la o eroare de validare funcția principală ieșea devreme și nu mai citea din canal. Am reprodus problema într-un test cu un fișier invalid și cu goleak, care a eșuat cum mă așteptam.

Rezultat: am trecut la errgroup cu context, ca worker-ii să se oprească la prima eroare, iar testul a trecut. Memoria a rămas stabilă după aceea. Am învățat să verific mereu cum se termină fiecare goroutine și acum am testul cu goleak în toate pachetele cu concurență.”

Ce face răspunsul bun:

  • arată o metodă, nu noroc: ipoteză, măsurare, reproducere, reparație, verificare;
  • conține detalii tehnice credibile;
  • își asumă propria greșeală, fără să dea vina pe alții.

Evită un bug banal sau o poveste a cărei cauză reală nu o poți explica.

Ce urmărește intervievatorul: Este cea mai frecventă întrebare comportamentală pentru programatori. Se evaluează metoda de depanare și onestitatea. O poveste vagă sau inventată se vede la prima întrebare suplimentară.

96 Junior

Primești o sarcină cu cerințe neclare. Cum procedezi?

Răspuns scurt: Îmi notez ce am înțeles și ce nu, încerc să clarific singur din cod, documentație și tichete anterioare, apoi pun întrebări concrete, grupate, persoanei care a cerut sarcina. Confirm în scris înțelegerea finală, inclusiv ce nu intră în sarcină, înainte să scriu mult cod.

Un răspuns structurat:

  • Înțeleg problema, nu doar cerința. Cine folosește funcționalitatea și ce încearcă să rezolve? Adesea cerința reală e diferită de cea formulată.
  • Fac temele întâi. Citesc codul existent, documentația, tichetele similare, ca să nu pun întrebări la care răspunsul e la un click distanță.
  • Pun întrebări concrete, de preferat cu variante: „Pentru exportul de comenzi, includem și comenzile anulate? Formatul e CSV, iar pentru volume mari presupun că trimitem fișierul pe e-mail, nu în răspunsul HTTP. E în regulă?”. E mai ușor de răspuns decât la „cum vreți să fie?”.
  • Confirm în scris: un comentariu în tichet cu ce fac, ce nu fac și criteriile de acceptare. Evită surprize la review.
  • Livrez devreme o variantă mică, de exemplu contractul API-ului sau un prototip, ca feedback-ul să vină înainte de a investi zile.

Model scurt de răspuns:

„La un proiect în echipă am primit sarcina «adăugați filtrare la lista de produse». Am citit endpoint-ul existent și am văzut că nu exista paginare, deci filtrarea pe mii de produse ar fi fost lentă. Am întrebat ce filtre contează pentru utilizatori, dacă e nevoie și de sortare și dacă putem schimba formatul răspunsului. Am scris în tichet propunerea, cu exemple de query parameters, iar colegul responsabil de frontend a cerut un filtru pe care nu-l luasem în calcul. Am implementat după acord, iar review-ul a durat puțin pentru că nu au existat surprize.”

La junior, o întrebare bună pusă la timp e apreciată.

Ce urmărește intervievatorul: Evaluează autonomia și comunicarea. Cele două extreme greșite sunt să ghicești cerințele fără să întrebi și să ceri ajutor fără să fi încercat nimic.

97 Mid

Cum reacționezi când nu ești de acord cu un comentariu de code review sau cu o decizie tehnică a unui coleg?

Răspuns scurt: Încep prin a înțelege argumentul celuilalt, apoi îmi explic poziția cu date concrete (comportament, performanță, risc), nu cu preferințe. Dacă nu ajungem la un acord, propun un test mic sau implic o a treia persoană și accept decizia echipei, chiar dacă nu e a mea.

Principii pe care le poți ilustra:

  • Pornește de la ipoteza că celălalt are un motiv bun. Adesea reviewer-ul știe ceva ce tu nu știi: un incident anterior, o convenție a echipei.
  • Separă faptele de gusturi. „Varianta asta face un query per element, deci 50 de query-uri pe pagină” e un argument. „Nu-mi place stilul” nu e. Pentru stil există gofmt și linterii, iar dezbaterea se mută în configurarea lor.
  • Adu dovezi: un benchmark, un test care arată un bug, documentația oficială, un exemplu din biblioteca standard.
  • Mută discuția în afara thread-ului când se lungește: o discuție de zece minute rezolvă ce 20 de comentarii nu rezolvă.
  • Acceptă și mergi mai departe când decizia e reversibilă și diferența e mică. Notează decizia, ca să nu fie rediscutată la fiecare PR.

Model STAR:

„Un coleg a cerut în review să înlocuiesc un sync.Mutex cu un canal și o goroutine dedicată, argumentând că e mai idiomatic. Am întrebat întâi ce problemă vedea și mi-a spus că se temea de deadlock-uri. Am explicat că secțiunea critică era doar actualizarea unui map, că varianta cu canal adăuga o goroutine care trebuia oprită corect și că testele rulau cu -race. Am atașat și un benchmark mic. Am căzut de acord să păstrăm mutex-ul, dar am adăugat la cererea lui un comentariu care spune ce câmpuri protejează. Discuția ne-a ajutat să scriem o regulă scurtă în ghidul echipei.”

Semnalul important: ai convingeri, dar nu le transformi în conflicte personale și știi când să cedezi.

Ce urmărește intervievatorul: Evaluează colaborarea și maturitatea profesională. Semnale proaste: a spune că nu ai avut niciodată dezacorduri sau a descrie colegul ca fiind „greșit” fără nuanțe.

98 Mid

Povestește o situație în care ai greșit și a afectat producția sau un coleg. Ce ai făcut?

Răspuns scurt: Spune o greșeală reală, asumată la persoana întâi. Arată ce ai făcut imediat ca să limitezi impactul și să comunici, cum ai găsit cauza și ce ai schimbat în proces ca greșeala să nu se poată repeta. Intervievatorul evaluează asumarea și învățarea, nu absența greșelilor.

Structura unui răspuns bun:

  • Greșeala, spusă direct, fără minimizare.
  • Reacția imediată: ai observat sau ai fost anunțat, ai comunicat, ai limitat impactul (rollback, fix rapid).
  • Cauza reală: nu doar „am greșit”, ci de ce a fost posibil.
  • Schimbarea durabilă: test, alertă, verificare în CI, checklist.

Model de răspuns:

„Am făcut deploy unei modificări care adăuga o coloană nouă și, în același release, codul începea să o citească. Migrația a rulat după ce câteva instanțe noi porniseră deja, așa că acestea au întors erori 500 pentru aproximativ zece minute pe un endpoint de comenzi.

Când a apărut alerta pe rata de erori, am anunțat în canalul echipei că e de la deploy-ul meu și am făcut rollback la versiunea anterioară. Apoi am rulat migrația manual și am refăcut deploy-ul.

Cauza nu era doar ordinea pașilor: pipeline-ul permitea ca migrațiile să ruleze în paralel cu pornirea aplicației. Am propus și am implementat un pas separat de migrare înaintea deploy-ului, care oprește pipeline-ul dacă migrația eșuează. Am adoptat și regula ca schimbările de schemă să fie compatibile cu versiunea anterioară a codului. Am scris un post-mortem fără vinovați, cu cronologia și acțiunile.”

De ce funcționează:

  • arată asumare fără autoflagelare;
  • arată comunicare rapidă, pe care echipele o valorează mai mult decât orice;
  • mută accentul de pe persoană pe sistem: o greșeală repetabilă de oricine e o problemă de proces.

Ce să eviți: „nu am greșit niciodată în producție”, o greșeală falsă de tip „lucrez prea mult” sau o poveste în care vina e a altcuiva.

Ce urmărește intervievatorul: Măsoară onestitatea și cultura de învățare. Un candidat care nu poate da un exemplu real fie are prea puțină experiență, fie nu e sincer.

99 Mid

Cum estimezi cât durează o sarcină și ce faci când îți dai seama că nu te încadrezi?

Răspuns scurt: Împart sarcina în pași mici și concreți, estimez fiecare pas, adaug timp pentru teste, review și necunoscute și comunic estimarea ca interval, cu presupunerile ei. Când văd că depășesc, anunț devreme, explic de ce și propun variante: reducerea scopului, ajutor sau un termen nou.

Cum arată o estimare credibilă:

  • Descompunere: „endpoint de export” devine query-ul și indexul necesar, formatul CSV, streaming pentru volume mari, autorizarea, testele, documentarea API-ului, deploy-ul;
  • Necunoscutele numite explicit: „nu știu încă dacă tabelul de comenzi are indexul potrivit; dacă nu, adaug o migrație”;
  • Interval, nu un punct: „două-trei zile, dacă nu apare problema cu indexul”;
  • Timpul ascuns: review, corecturi după review, CI lent, întâlniri. Juniorii estimează de obicei doar timpul de scris cod;
  • Comparație cu sarcini similare făcute anterior, dacă există.

Pentru necunoscute mari propui un spike: o investigație limitată în timp (de exemplu o jumătate de zi), după care dai o estimare reală.

Când nu te încadrezi:

  • anunți imediat ce știi, nu în ziua termenului. O întârziere anunțată devreme e o informație de planificare; una anunțată târziu e o surpriză;
  • explici cauza concret: „integrarea cu API-ul de plăți întoarce un format diferit de documentație”;
  • propui variante: livrăm întâi exportul fără filtre, cerem ajutorul cuiva care a lucrat cu acel API sau mutăm termenul cu două zile.

Model scurt:

„La o sarcină estimată la trei zile am descoperit în a doua zi că biblioteca de PDF nu suporta diacriticele românești. Am anunțat în stand-up, am propus o zi de investigare pentru o alternativă și am livrat între timp partea de date, testată. Am încheiat cu o zi întârziere, dar nimeni nu a fost surprins. De atunci verific la început compatibilitatea bibliotecilor noi.”

Nimeni nu așteaptă estimări perfecte. Se așteaptă transparență.

Ce urmărește intervievatorul: Evaluează responsabilitatea și comunicarea despre progres. Semnalul negativ este tăcerea până în ziua termenului sau promisiunea fără nicio descompunere.

100 Senior

Cum ai ajuta un junior din echipă să crească și cum argumentezi o decizie tehnică importantă în fața echipei?

Răspuns scurt: Pe un junior îl ajuți cu sarcini de dificultate crescătoare, review-uri care explică de ce și pair programming, într-un mediu unde poate greși în siguranță. O decizie importantă o argumentezi în scris: problema, variantele, trade-off-urile și criteriile de evaluare.

Mentoratul, concret:

  • sarcini cu dificultate crescătoare: întâi o modificare izolată, bine definită, apoi o funcționalitate de la cap la coadă, apoi ceva cu concurență sau migrații de date;
  • review-uri care predau: în loc de „schimbă asta”, „aici, dacă contextul e anulat, goroutina rămâne blocată la trimitere; vezi cum ar arăta cu select”. Separă comentariile obligatorii de cele opționale, ca juniorul să știe ce contează;
  • pair programming pe probleme reale, cu juniorul la tastatură;
  • siguranță: greșelile se discută ca probleme de sistem, iar întrebările nu sunt tratate ca semn de incompetență;
  • feedback regulat, nu doar la evaluări.

Argumentarea unei decizii se face printr-un document scurt (un design doc sau un ADR, Architecture Decision Record):

  • contextul și problema, cu date: „latența p99 a crescut de la ... după ...” (cifrele reale din sistem);
  • două-trei variante realiste, inclusiv „nu facem nimic”;
  • trade-off-urile fiecăreia: complexitate, cost, risc, timp, ce știe echipa;
  • recomandarea și criteriile de evaluare ulterioară;
  • planul de revenire dacă nu funcționează.

Model scurt:

„Când echipa a vrut să treacă toate serviciile pe gRPC, am scris un document care compara gRPC intern plus REST public cu varianta actuală. Am propus un pilot pe două servicii interne, cu metrici de latență și timp de dezvoltare. Am primit obiecții legate de depanare, așa că am inclus grpcurl și logarea mesajelor în plan. După pilot, decizia a fost luată pe date.”

Un senior nu câștigă discuții prin autoritate, ci face ușor pentru ceilalți să ajungă la decizia bună.

Ce urmărește intervievatorul: Evaluează leadership-ul tehnic fără titlu formal. Semnalele proaste: mentorat redus la „le spun ce să facă” sau decizii impuse fără alternative analizate.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Backend Developer Go (cloud)

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Backend Developer Go (cloud), de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Backend Developer Go (cloud)

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.