Glosario de supervivencia dev 👨‍💻

---

¡Hola Chiquis!👋🏻 entrar al mundo del software es como mudarse a un país donde todos hablan un dialecto extraño mezcla de inglés, acrónimos y metáforas de construcción. Si alguna vez te has sentido perdido en una daily, este post es tu brújula. Este no es solo un glosario de términos de software. Es un mapa del viaje profesional que vivimos en tecnología: del asombro al criterio.

Hay palabras que marcan etapas. Al inicio suenan a idioma extranjero; luego se vuelven herramientas; y un día, sin darte cuenta, ya son parte de tu forma de pensar. En la industria de TI, las palabras son herramientas. Usar el término correcto no solo te hace sonar profesional, sino que demuestra madurez técnica. Vamos a desglosar esta sopa de letras por niveles de experiencia.

🌱 Nivel 0: Principiante

Las primeras palabras son llaves: abren puertas a la comprensión.

• Variable: espacio en memoria donde guardas datos.
• Función: bloque reutilizable de lógica.
• Bug: error en el software. Ese “hijo no deseado” del código. Un error que hace que el programa se comporte de forma errática.
• Compilar: traducir código a ejecutable.
• Repositorio: carpeta del proyecto con control de versiones.
• Framework: estructura base para desarrollar. El esqueleto prefabricado. No reinventas la rueda, usas una que ya funciona y le pones tus propios rines.
• Frontend: el maquillaje y la ropa (lo que ves). Parte de una aplicación o sitio web con la que los usuarios interactúan directamente, conocida como interfaz gráfica de usuario (GUI). Comprende todo lo visible, diseño, menús, botones, imágenes, y se construye con HTML (estructura), CSS (estilo) y JavaScript (interactividad), ejecutándose en el navegador del cliente.
• Backend: los órganos y el cerebro (lo que hace que funcione). Parte del sistema que corre en servidor, maneja lógica de negocio y persistencia. Ejemplo: consulta SQL segura en Python usando parámetros.

# get_user.py
import sqlite3

def get_user(user_id):
    conn = sqlite3.connect('app.db')
    cur = conn.cursor()
    cur.execute('SELECT id, name FROM users WHERE id = ?', (user_id,))
    row = cur.fetchone()
    conn.close()
    return row

print(get_user(1))

Explicación: usar ? evita inyección SQL. Un senior añadirá pooling, ORM y manejo de errores.

1. 👉 Etapa emocional: curiosidad + confusión.
2. 👉 Frase típica: “creo que ya entendí… bueno, más o menos.”

🐣 Nivel 1: Junior

Aquí es donde construyes los cimientos. Si no dominas esto, el compilador será tu peor enemigo. Aquí el vocabulario se vuelve práctico. Empiezas a trabajar en equipo.

• API (Application Programming Interface): el “mesero” del software. Tú pides algo (request), la API va a la cocina (servidor) y te trae la comida (data). Puente entre sistemas. Contrato que define cómo comunicarse entre sistemas. Ejemplo: endpoint REST simple en Node.js (Express).

// server.js
const express = require('express');
const app = express();
app.use(express.json());

app.get('/api/users/:id', (req, res) => {
  const id = req.params.id;
  // Simula fetch a DB
  res.json({ id, name: 'Orli', role: 'engineer' });
});

app.listen(3000, () => console.log('API running on :3000'));

Explicación: GET /api/users/:id es el contrato: cliente envía id, servidor responde JSON. Un senior añadirá versionado /v1/users/:id, validación y documentación (OpenAPI).

• Commit: es como darle a “Guardar” en un videojuego, pero con un mensaje que explica qué demonios hiciste. Guardar cambios con historia.
• Pull Request (PR): solicitud para integrar cambios. Es la solicitud para integrar cambios; merge es la acción de unir ramas. Ejemplo: crear una rama, hacer cambios, commitear y abrir PR.

git checkout -b feature/login
# haces cambios...
git add .
git commit -m "feat: login básico"
git push origin feature/login
# Luego abres PR en la plataforma (GitHub/GitLab)

Explicación: escribe commits pequeños y descriptivos; en PR incluye descripción, pasos para probar y screenshots si aplica.

• Merge: unir ramas de código.
• Branch: línea paralela de desarrollo.
• Debugging: encontrar y corregir errores.
• Testing: validar que el código funcione.
• Deploy: publicar el sistema. Lanzar el código al mundo real (y cruzar los dedos). Proceso de poner una versión del software en un entorno accesible (staging/producción). Ejemplo: comando simple con Docker y Heroku (conceptual).

# Construir imagen
docker build -t myapp:1.0 .
# Subir a registry y desplegar (simplificado)
docker push registry.example.com/myapp:1.0
# En el servidor: docker run -d registry.example.com/myapp:1.0

Explicación: en producción se añade orquestador (Kubernetes), monitoreo y rollback automatizado.

• Agile: metodología que prioriza entregas incrementales, feedback continuo y adaptación al cambio. En la empresa se usa para planificar sprints; en la universidad aparece en asignaturas de gestión de proyectos. Ejemplo: no es código, pero sí una práctica: escribe una user story y descompónla en tareas pequeñas para un sprint.
• Endpoint: punto de acceso de una API.
• Stack: conjunto de tecnologías usadas.

1. 👉 Etapa emocional: orgullo + síndrome del impostor.
2. 👉 Frase típica: “funciona… pero no sé si está bien hecho.”

👨‍💻 Nivel 2: Mid-Level - Semi-Senior

Aquí es donde dejas de preocuparte solo por que “funcione” y empiezas a preocuparte por que sea mantenible. Dejas de solo programar: comienzas a diseñar.

• CI/CD (Continuous Integration / Continuous Deployment): el arte de automatizar que tu código llegue a producción sin que tengas que apretar 20 botones y rezar tres padres nuestros. Conjunto de prácticas para integrar cambios (CI) y desplegarlos automáticamente (CD). Ejemplo: fragmento de pipeline (GitHub Actions) que corre tests y build.

# .github/workflows/ci.yml
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node
        uses: actions/setup-node@v3
        with: node-version: '18'
      - run: npm ci
      - run: npm test

Explicación: cada push dispara tests; si fallan, el PR no se mergea. Un senior añadirá despliegue condicional y análisis de cobertura.

• Deuda técnica (Technical Debt): el “lo arreglo mañana”. Es el interés que pagas (en tiempo y estrés) por tomar atajos hoy. Spoiler: mañana nunca llega. Problemas futuros por atajos actuales.
• Refactorizar: limpiar la casa sin cambiar los muebles de sitio. Mejorar la estructura interna del código sin alterar su comportamiento externo, es decir, cambiar la estructura del código sin alterar su comportamiento observable. Ejemplo: extraer función para mejorar legibilidad en JavaScript.

// Antes
function process(items) {
  return items.filter(i => i.active).map(i => i.value * 2);
}

// Después (refactor)
const isActive = i => i.active;
const doubleValue = i => i.value * 2;

function process(items) {
  return items.filter(isActive).map(doubleValue);
}

Explicación: el comportamiento no cambia, pero el código es más testable y legible.

• Middleware: el “pegamento” que se sienta en medio de dos aplicaciones para que puedan hablar entre ellas sin pelearse.
• Code review: ese momento de humildad donde tus colegas encuentran los 3 puntos y coma que olvidaste y cuestionan tu existencia (para bien).
• Arquitectura: estructura del sistema.
• Patrones de diseño (Design Patterns): solución reutilizable a problemas comunes. Soluciones estándar a problemas comunes. Es saber que no eres el primero en enfrentar este caos y que alguien ya inventó una forma elegante de resolverlo.
• Escalabilidad: capacidad de crecer sin romperse. La capacidad de tu sistema de no explotar cuando pasas de 10 usuarios a 10 millones.
• Performance: eficiencia del sistema.
• Acoplamiento: dependencia entre componentes.
• Cohesión: relación lógica dentro de un módulo.

1. 👉 Etapa emocional: criterio en construcción.
2. 👉 Frase típica: “podría funcionar mejor si cambiamos la arquitectura.”

🧠 Nivel 3: Senior

En este nivel, el código es lo de menos. Lo importante es la estrategia, la escalabilidad y la resiliencia. Las palabras ahora son estratégicas. Hablas de impacto, no solo de código.

• Sistema distribuido: componentes en múltiples nodos.
• Resiliencia: capacidad de recuperarse ante fallos.
• Consistencia: integridad de datos en el tiempo.
• Event-Driven: arquitectura basada en eventos.
• Trade-off: decisión con ventajas y costos.
• Dominio: área de negocio del software.
• Gobernanza técnica: decisiones estructurales del ecosistema.
• Legado (Legacy Code): código antiguo que nadie quiere tocar porque es el que mantiene viva a la empresa. Se mira con respeto y miedo.
• Idempotencia: una palabra elegante para decir que si haces la misma operación 100 veces, el resultado final siempre será el mismo. Vital para sistemas de pagos.
• Observabilidad: no es solo tener logs; es entender qué está pasando dentro de tu sistema sin tener que abrirlo, basándote en los datos que genera. Entender el estado interno del sistema.

1. 👉 Etapa emocional: responsabilidad + visión.
2. 👉 Frase típica: “depende del contexto.”

🗣️ Lo que usualmente se dice

Para moverte como pez en el agua entre colegas, necesitas este diccionario de bolsillo:

• Hotfix: un parche urgente porque algo se rompió en producción y el jefe está mirando.
• Rubber Ducking: explicarle tu código a un patito de goma para darte cuenta tú mismo de por qué no funciona.
• LGTM: “Looks Good To Me”. La bendición que recibes en un Pull Request.
• Stand-up: una reunión de 15 minutos que dura 45 donde todos dicen que están “trabajando en ello”.

Buenas prácticas y atajos de senior

• Documenta las APIs con OpenAPI/Swagger; facilita integraciones.
• Automatiza pruebas: unitarias + integración + end‑to‑end en pipelines.
• Pequeños commits y PRs claros aceleran revisiones.
• Refactor frecuente evita deuda técnica acumulada.

🧭 El verdadero salto de junior a senior no es técnico

Es lingüístico y mental. Pasas de preguntar: “¿Cómo se hace?”. A cuestionar: “¿Por qué hacerlo así?”. Y finalmente a decidir: “¿Qué conviene más para el negocio y el equipo?”

Conclusión

Aprender la terminología no es para presumir en LinkedIn. Es para reducir la fricción. Cuando un equipo habla el mismo idioma, las ideas fluyen más rápido y los errores disminuyen. No te asustes si al principio suena a chino; todos empezamos preguntando qué era un “JSON”. Cada término que aprendes cambia tu forma de ver el software. Y también cambia cómo colaboras, cómo decides y cómo lideras.

El verdadero senior no es el que usa las palabras más complejas, sino el que sabe explicar conceptos complejos con las palabras más simples. Porque en tecnología, el vocabulario no solo describe la realidad… la construye. Si aprendiste algo nuevo, comparte este glosario con ese compañero que siempre pregunta “¿qué es un merge conflict?” y guarda el post para repasar.

¿Hay algún término que escuchaste hoy y te dejó con cara de “404 Not Found”? Te leo 👇

¡Gracias por acompañarme en esta aventura tech! 👩🏻‍🦰 👩🏻‍💻✨

🚀 ¿Te ha inspirado este contenido? Me encantaría saber tu opinión o leer tus experiencias. 🧡

Si quieres explorar más de lo que estoy creando (proyectos, blogs, contenido tech y novedades en IA/ML), te invito a visitar:

• 🎯 orli_.app

Y si prefieres conectar:

• 🔗 Conecta conmigo en Linkedin
• 📚 Mi blog personal

✨ Code with heart - Create with soul ✨

Referencias: Imágenes creadas con Gemini (google.com)

#porunmillondeamigos #makeyourselfvisible #creatorcontent #linkedin #developers #opentowork #DesarrolloDeSoftware #GlosarioDev #Programación #IngenieríaDeSoftware #CarreraTech #AprenderProgramación #TechCareers