Cómo aprobar una entrevista de Go: preguntas y respuestas avanzadas

Cómo aprobar una entrevista de Go: preguntas principales de nivel avanzado

Una entrevista para un puesto de desarrollador Go no es solo una prueba de sintaxis. A nivel avanzado, los entrevistadores quieren ver una comprensión profunda de la concurrencia, la gestión de memoria, el funcionamiento del planificador y los modismos del lenguaje. En este artículo, analizaremos las preguntas clave que suelen hacer a los ingenieros senior, con ejemplos de código y explicaciones. El material será útil tanto para la preparación como para sistematizar conocimientos.

1. Concurrencia: gorutinas, canales y primitivas de sincronización

Go es famoso por su soporte integrado de concurrencia. Los entrevistadores casi siempre verifican cómo el candidato entiende la diferencia entre gorutinas y hilos del SO, así como si sabe usar correctamente los canales y el paquete sync.

Pregunta: ¿Cuál es la diferencia entre una gorutina y un hilo del SO?

Una gorutina es un hilo ligero gestionado por el planificador de Go (modelo G-M-P). Tiene su propia pila, que comienza con 2-4 KB y puede crecer dinámicamente. Un hilo del SO es un objeto pesado con una pila fija (normalmente 1-8 MB). Miles de gorutinas pueden ejecutarse en un solo hilo del SO, lo que hace que su creación y cambio sean muy económicos.

Pregunta: ¿Cómo evitar condiciones de carrera (data race) al trabajar con gorutinas?

Use canales para transferir datos entre gorutinas ("No se comunique compartiendo memoria; en su lugar, comparta memoria comunicándose") o mutexes (sync.Mutex, sync.RWMutex). Siempre verifique el código con la bandera -race.

var counter intvar mu sync.Mutex

func increment() {    mu.Lock()    counter++    mu.Unlock()}

Pregunta: Explique el principio de funcionamiento de select. ¿Qué sucede si todos los canales están bloqueados?

select permite que una gorutina espere múltiples operaciones de canal simultáneamente. Si todos los canales están bloqueados, select esperará hasta que uno de ellos esté listo. Si hay un default, se ejecutará inmediatamente, evitando el bloqueo.

select {case msg := <-ch1:    fmt.Println("Recibido de ch1:", msg)case ch2 <- "data":    fmt.Println("Enviado a ch2")default:    fmt.Println("Ningún canal está listo")}

2. Gestión de memoria y recolector de basura (GC)

Para un nivel avanzado, es importante entender cómo funciona la asignación en Go, dónde se colocan las variables (pila/montón) y cómo el recolector de basura afecta el rendimiento.

Pregunta: ¿Cómo decide Go si colocar una variable en la pila o en el montón?

Go utiliza análisis de escape (escape analysis). Si el compilador puede demostrar que una variable no se usa después de que la función retorna (no "escapa" hacia afuera), se coloca en la pila. De lo contrario, en el montón. Por ejemplo, devolver un puntero a una variable local hace que "escape" al montón.

func createUser() *User {    u := User{Name: "Alice"}    return &u // escape al montón}

Pregunta: ¿Cómo funciona el recolector de basura en Go? ¿Qué fases atraviesa?

El GC en Go es un recolector de basura paralelo tricolor (mark-sweep). Atraviesa tres fases:

• Mark Setup (STW): breve parada del mundo para activar la barrera de escritura.
• Marking: fase paralela que marca los objetos vivos. Funciona junto con la aplicación.
• Sweep: limpieza de la memoria no utilizada, generalmente se aplaza.

El tiempo de STW (Stop The World) suele ser < 500 µs, lo que hace que Go sea adecuado para aplicaciones sensibles a la latencia.

Pregunta: ¿Cómo reducir la carga en el GC?

• Evite asignaciones frecuentes (use grupos de objetos sync.Pool).
• Reutilice slices con slice[:0].
• Aumente el valor de