Entiende el hardwarebajo tu código

Qué ocurre bajo tu código: procesos, hilos, memoria y E/S, y cómo determinan que una aplicación sea rápida, estable o se caiga. Para razonar el rendimiento en lugar de memorizar recetas.

Empezar

Acceso al curso completo, ejercicios y material de entrevista.

// Un proceso se duplica con fork(): padre e hijo
pid_t pid = fork();

if (pid == 0) {
    printf("Soy el hijo, PID %d\n", getpid());
} else {
    printf("Soy el padre, hijo = %d\n", pid);
    wait(NULL);  // espera a que el hijo termine
}

→Soy el padre, hijo = 4812

→Soy el hijo, PID 4812

⧗Mismo código, dos procesos con memoria separada

# Race condition: += no es atómico
import threading

contador = 0
def sumar():
    global contador
    for _ in range(100_000):
        contador += 1  # leer, sumar, escribir

hilos = [threading.Thread(target=sumar) for _ in range(4)]

→Esperado: 400000

→Real: 312847 ← se pierden incrementos

⧗Sin lock, dos hilos pisan la misma escritura

# La jerarquía de memoria: cada salto es ~10x-100x
registro CPU    ~ 0.3 ns
caché L1        ~ 1   ns
caché L2        ~ 4   ns
RAM             ~ 100 ns
SSD             ~ 16000 ns
disco (HDD)     ~ 2000000 ns

# Por eso la localidad de los datos importa

→Acceso a RAM ≈ 300x más lento que a L1

→Acceso a disco ≈ millones de ciclos de CPU

⧗El cuello de botella casi nunca es la CPU

Orientado a entrevistas

No solo aprendes sistemas. Te preparas para que te contraten.

Banco orientado a la entrevista técnica: proceso vs hilo, stack vs heap, race conditions y diagnosticar por qué un programa va lento.

Preguntas

Preguntas reales de entrevistas técnicas.

Errores comunes

Lo que delata a un junior frente al entrevistador.

Retos de debug

Diagnóstico de concurrencia y memoria.

Qué vas a aprender

De fork() a entender por qué tu sistema es rápido o se cae

Qué pasa de verdad al ejecutar código

Del fuente al binario, el papel del sistema operativo y las llamadas al sistema.

Memoria sin misterios

Stack y heap, memoria virtual, fugas y por qué valor vs referencia importa.

Procesos, hilos y concurrencia

Qué los diferencia, condiciones de carrera y cómo se sincroniza sin romperlo todo.

E/S, archivos y red desde el sistema

Descriptores, E/S bloqueante vs no bloqueante, sockets y multiplexación.

Por qué un programa es lento

CPU vs E/S, jerarquía de caché, latencia frente a throughput y dónde medir.

Razonar como un ingeniero de sistemas

Diagnosticar memoria, descriptores y cuándo escalar la máquina o el diseño.