De DOS a Cloud: mi viaje de 33 años con la tecnología — desde una Amiga en 1994 hasta deployar en Railway con Next.js

Hay una foto mía de 1994 que mi vieja guarda en un álbum de plástico verde. Tengo tres años, el pelo cortado a tazón, y estoy sentado frente a una Amiga 500 con una expresión de concentración absoluta. No sé qué estaba mirando. Probablemente algún juego en floppy que mi viejo había copiado de no sé dónde. Pero esa imagen es mi origen story. El big bang personal de esta historia de programador argentino que arrancó antes de que yo pudiera leer.

La Amiga no era una computadora. Era un universo.

La Commodore Amiga 500 era una máquina que en 1994 ya estaba técnicamente muerta en el mercado mundial, pero en Argentina —tierra de contratiempos gloriosos— todavía vivía y coleaba. Mi viejo la había conseguido no sé cómo, en algún intercambio de esos que solo existían en la Argentina de los noventa.

Tenía 512KB de RAM. Corría un sistema operativo multitarea cuando Windows todavía era una cáscara patética sobre DOS. Reproducía samples de audio de 8 bits cuando las PC de IBM apenas podían hacer beeps. Era, objetivamente, una computadora superior que el mercado abandonó por razones políticas y comerciales que me siguen pareciendo un crimen.

Yo no entendía nada de eso. Solo sabía que cuando encendías esa caja gris y metías el kickstart disk, aparecía una pantalla de colores imposibles para la época y el mundo se abría.

Ahí empezó todo.

A los 5 años: mi primer dominio (y no tenía idea de lo que era)

Esto suena a cuento pero es verdad. Mi viejo, que trabajaba en algo relacionado con importaciones y exportaciones, había empezado a meterse en internet alrededor de 1996. Para 1998, cuando yo tenía 5 años, teníamos conexión dial-up y él me dejaba jugar en la computadora.

Registré mi primer dominio —bueno, él lo registró, yo le dije el nombre— porque quería tener "mi propio lugar en internet" para poner dibujos. No entendía absolutamente nada de lo que implicaba un dominio. Para mí era como poner tu nombre en la puerta de una habitación.

Pero esa intuición de que el nombre importa, de que el espacio digital es tuyo si lo reclamás, se quedó grabada a fuego.

Los 14 años y el cyber de Palermo: donde aprendí redes a los golpes

Aquí viene la parte visceral.

Era 2005. Argentina salía de la crisis del 2001 con las costillas rotas pero con ganas de vivir. Los cyber cafés eran el corazón tecnológico del barrio. No había WiFi en todos lados, las netbooks del Plan Ceibal no existían todavía, y si querías jugar Counter-Strike con tus amigos o bajar música de Ares (sí, Ares, no me arrepiento), ibas al cyber.

Yo conseguí laburar en uno. Tenía 14 años, ninguna calificación formal, y el dueño —un tipo de unos 45 que había montado el negocio con sus ahorros— me contrató porque era el único que sabía reiniciar el servidor cuando se colgaba sin romper nada.

Ahí aprendí redes. No en un libro. Aprendí porque cuando se caía la conexión a las 10 de la noche con el local lleno de pibes gritando que habían perdido la partida, tenías que diagnosticar y solucionar ya.

Aprendí qué era un DHCP server cuando el servidor de Windows 2000 dejó de asignar IPs y todos los equipos se quedaron con APIPA (169.254.x.x — ese rango de direcciones me genera PTSD hasta el día de hoy). Aprendí qué era un switch, un hub, la diferencia entre los dos, por qué los hubs eran una basura para gaming (colisiones de paquetes, latencia impredecible). Aprendí a configurar VLANs básicas en switches Cisco de segunda mano que el dueño había comprado en la Feria de La Salada.

Ningún libro me enseñó eso. Me lo enseñó la presión, la adrenalina, y el miedo a que me echaran.

A los 18: Linux, web hosting, y mi primera crisis existencial técnica

Salté del cyber al mundo del web hosting. 2009. Era la época en que Fibertel empezaba a ser algo, en que WordPress ya existía pero todavía la gente construía sitios en Dreamweaver, en que PHP 5 era lo más nuevo del mundo.

Instalé mi primer servidor Linux en una máquina física. Un Pentium 4 reconvertido en servidor con Ubuntu Server 8.04. Sin interfaz gráfica. Solo terminal.

Recuerdo el momento exacto en que levanté mi primer VirtualHost en Apache:

<VirtualHost *:80>
    ServerName miprimerodomain.com.ar
    DocumentRoot /var/www/miprimerodomain
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Parece una boludez. Pero cuando escribís esa configuración, hacés sudo service apache2 reload, abrís el browser y tu dominio carga desde tu propia máquina... algo en tu cerebro hace click. Entendés, a nivel visceral, cómo funciona internet. No como concepto abstracto. Como infraestructura real que vos estás controlando.

Esa sensación no la cambio por nada.

También me rompí la cabeza mil veces. Configuré mal un servidor de correo y quedé en listas negras de spam. Borré /var/www entero con un rm -rf mal escrito (sí, me pasó, sí, quería morirme). Aprendí qué era un backup después de necesitarlo desesperadamente. Todas lecciones que ningún tutorial te enseña porque solo las aprendés cuando el dolor es real.

La CCNA y la UBA: el intento de formalizar el caos

Estudié para el Cisco CCNA porque sentía que mi conocimiento era un archipiélago de islas sin puentes. Sabía hacer cosas pero no entendía la arquitectura completa. El CCNA me dio el framework teórico que ordenó todo el ruido.

OSI model. TCP/IP stack. Spanning Tree Protocol. OSPF. BGP en sus formas más básicas. Todo eso que yo había tocado empíricamente de golpe tenía nombre, estructura, razón de ser.

Después entré a Ciencias de la Computación en la UBA. Y ahí me rompieron la cabeza de otra manera. Álgebra, cálculo, algoritmos, complejidad computacional. La diferencia entre O(n) y O(n²) no es académica — es la diferencia entre una app que escala y una que muere bajo carga.

La UBA me enseñó a pensar. El cyber me había enseñado a hacer. Necesitaba los dos.

2020: El pivot. El año que lo cambió todo.

Vino la pandemia y, como a muchos, me dejó encerrado con tiempo y con preguntas. Estaba haciendo cosas de infraestructura, sysadmin, algo de DevOps. Pero el desarrollo de software siempre me había llamado y siempre había postergado el salto.

En marzo de 2020, con el mundo en llamas, decidí: ahora.

Empecé con JavaScript vanilla. Después React. Después TypeScript (y al principio lo odiaba — todos odian TypeScript al principio, el que dice que no, miente). Después Next.js.

El primer componente React que escribí fue horrible:

// Esto es arqueología. No juzguen.
function MiComponente() {
  var nombre = "Juan";
  return (
    <div>
      <p>Hola {nombre}</p>
    </div>
  )
}

Sin hooks. Sin TypeScript. Sin nada. Pero funcionaba y eso era suficiente para seguir.

Después de meses de iteración, el mismo componente empezó a verse así:

interface GreetingProps {
  userId: string;
  fallbackName?: string;
}

const Greeting: React.FC<GreetingProps> = ({ userId, fallbackName = 'amigo' }) => {
  const { data: user, isLoading } = useUser(userId);

  if (isLoading) return <Skeleton className="h-6 w-32" />;

  return (
    <p className="text-lg font-medium">
      Hola, {user?.displayName ?? fallbackName}
    </p>
  );
};

export default Greeting;

La distancia entre esos dos fragmentos de código es la distancia entre no saber y empezar a saber. Y esa distancia se mide en horas de frustración, en Stack Overflow a las 2AM, en errores de TypeScript que no entendés hasta que de repente entendés todo.

Hoy: Docker, PostgreSQL, Railway, y el deploy que me hace sentir poderoso

Hoy mi stack es Next.js 14, TypeScript, PostgreSQL con Prisma, Docker para desarrollo local, y Railway para producción. Y cuando hago deploy de una app completa —con su base de datos, sus variables de entorno, su dominio custom— todavía siento algo. No sé si llamarlo orgullo o simplemente satisfacción profunda.

Mi docker-compose.yml de desarrollo típico:

version: '3.8'
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - /app/node_modules
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@db:5432/myapp
    depends_on:
      - db

  db:
    image: postgres:15-alpine
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Eso es infraestructura reproducible. Cualquier dev del equipo hace docker compose up y tiene el entorno exacto. Sin "en mi máquina funciona". Sin dependencias fantasma.

Hay una línea directa entre configurar Apache en Ubuntu 8.04 en 2009 y escribir ese docker-compose.yml en 2024. Es la misma obsesión por entender cómo las piezas encajan.

Lo que 33 años de tecnología me enseñaron (en serio)

No hay atajos para la intuición técnica. Podés aprender sintaxis en un fin de semana. La intuición — saber por qué algo falla antes de leer el error, entender cómo va a escalar un sistema, anticipar los edge cases — esa intuición se construye con tiempo y con dolor.

La historia de este programador argentino no es una historia de genialidad. Es una historia de exposición acumulada. De estar cerca de la tecnología desde tan chico que las capas de abstracción se fueron volviendo transparentes de a poco.

Cada error que cometí —el rm -rf, las configuraciones rotas, los servidores de correo en listas negras— me dejó algo. Una cicatriz que ahora es conocimiento.

Y la Amiga 500. Siempre vuelvo a la Amiga. Esa máquina que hacía más con menos, que era técnicamente superior y perdió igual, que vivió en Argentina cuando ya estaba muerta en el mundo, me enseñó algo sin que yo lo supiera: la tecnología no siempre gana el que la merece. Gana el que la adopta, la empuja, la hace suya.

Eso es lo que hago. Hace 33 años. Y no paro.