Tema 46 – Lenguajes de Programación PROFUNDIZADO – TFA-STI SAS

Tema 46 - PROFUNDIZADO

Lenguajes de Programación: Características, Traductores y Estado del Arte

Análisis exhaustivo de compiladores, intérpretes, lenguajes modernos y entornos de desarrollo para TFA-STI SAS

Introducción - Fundamentos Técnicos

Los lenguajes de programación son abstracciones que permiten a humanos escribir instrucciones que las computadoras pueden entender y ejecutar. La evolución de estos lenguajes ha sido fundamental en la historia de la informática. Este tema profundiza exhaustivamente en cómo funcionan los traductores (compiladores, intérpretes, ensambladores), las características fundamentales de los lenguajes modernos (Java, .NET, Python), los lenguajes de scripting y los entornos de desarrollo integrados. Comprender estos conceptos es esencial para cualquier profesional de TI que desarrolle sistemas en contextos modernos como el del Servicio Andaluz de Salud.

1. Niveles de Lenguajes: De Máquina a Alto Nivel

1.1 Jerarquía de Lenguajes de Programación

Niveles de Abstracción:

Nivel 5 (Más Alto): Lenguajes de Alto Nivel

↓ Ejemplos: Python, Java, C#, JavaScript

↓ Características: Legibles por humanos, portátiles, abstracción total del hardware

↓

Nivel 4: Lenguajes Intermedios/Bytecode

↓ Ejemplos: Java Bytecode, .NET IL (Intermediate Language)

↓ Características: No ejecutables directamente, requieren máquina virtual

↓

Nivel 3: Lenguaje Ensamblador

↓ Ejemplos: x86 Assembly, ARM Assembly

↓ Características: Mnemonics para operaciones máquina, cercano al hardware

↓

Nivel 1-2 (Más Bajo): Código Máquina

↓ Ejemplos: 10110101 11000101 (binario puro)

↓ Características: Único ejecutable por CPU, específico de arquitectura

2. Traductores: El Eslabón Crítico

2.1 Concepto de Traductor de Lenguajes

Definición técnica: Un traductor es un programa especial que convierte código fuente escrito en un lenguaje de programación en código que la máquina puede ejecutar (código máquina, bytecode o código interpretable).

2.2 Tres Tipos Principales de Traductores

ENSAMBLADOR (Assembler)

Entrada: Código Ensamblador

Salida: Código Máquina

Relación: 1:1 (Casi siempre)

Complejidad: Baja

Ejemplo:

MOV AX, 5
ADD AX, 3
JMP FIN

↓ ENSAMBLADOR ↓

10110000 01100001
00000100 00000011
11101011 11111110

COMPILADOR (Compiler)

Entrada: Código Alto Nivel

Salida: Código Máquina o Bytecode

Relación: 1:Muchos

Complejidad: Muy Alta

Ejemplo:

int main() {
  int x = 5;
  x = x + 3;
}

↓ COMPILADOR ↓

[Cientos de líneas de código máquina]

INTÉRPRETE (Interpreter)

Entrada: Código Alto Nivel

Salida: Ejecución directa

Relación: Línea por línea

Complejidad: Alta

Ejemplo:

x = 5
x = x + 3
print(x)

↓ INTÉRPRETE ↓

Lee, traduce y ejecuta cada línea

2.3 Comparativa Detallada de Traductores

Aspecto	Ensamblador	Compilador	Intérprete
Nivel de Abstracción	Bajo (casi máquina)	Alto (lenguaje natural)	Alto (lenguaje natural)
Tiempo de Traducción	Rápido (1:1)	Lento (análisis complejo)	Medio (línea por línea)
Tiempo de Ejecución	Inmediato (ya binario)	Inmediato (ya compilado)	Lento (traducción+ ejecución)
Portabilidad	Nula (específico CPU)	Alta (recompilar)	Alta (mismo intérprete)
Detección Errores	En tiempo ejecución	En tiempo compilación	En tiempo ejecución
Optimización	Manual en código	Automática (compiler)	Limitada
Ejemplos	x86, ARM, MIPS	C, C++, Java, Go	Python, Ruby, JavaScript

2.4 Proceso de Compilación Detallado

Un compilador típico realiza 6 fases:

FASE 1: ANÁLISIS LÉXICO
────────────────────────
Entrada: "int x = 5 + 3;"
Salida: [Palabra clave: int] [Identificador: x] [Operador: =] [Número: 5] 
         [Operador: +] [Número: 3] [Puntuación: ;]

FASE 2: ANÁLISIS SINTÁCTICO
────────────────────────────
Verifica que los tokens formen frases válidas
Construye Árbol de Sintaxis Abstracta (AST)
       =
      / \
     x   +
        / \
       5   3

FASE 3: ANÁLISIS SEMÁNTICO
───────────────────────────
Verifica que x sea int
Verifica que 5 y 3 sean compatibles con int
Verifica que + sea válido para int

FASE 4: GENERACIÓN CÓDIGO INTERMEDIO
──────────────────────────────────────
temp1 = 5 + 3
x = temp1

FASE 5: OPTIMIZACIÓN
─────────────────────
x = 8  (optimiza 5+3 a 8 en tiempo compilación)

FASE 6: GENERACIÓN CÓDIGO MÁQUINA
──────────────────────────────────
MOV AX, 8
MOV [x], AX

2.5 Diferencia Crítica: Compilación vs Interpretación

PROGRAMA ORIGINAL (Python):
x = 5
y = x + 3
print(y)

═══════════════════════════════════════════════════════

COMPILACIÓN (Java):
1. Compilar TODO el programa ANTES de ejecutar
2. Genera archivo .class (bytecode)
3. La máquina virtual ejecuta el bytecode
4. MÁS RÁPIDO (ejecución)
5. Errores detectados antes de ejecutar

═══════════════════════════════════════════════════════

INTERPRETACIÓN (Python):
1. Intérprete lee línea 1: "x = 5" → la traduce → la ejecuta
2. Intérprete lee línea 2: "y = x + 3" → la traduce → la ejecuta
3. Intérprete lee línea 3: "print(y)" → la traduce → la ejecuta
4. MÁS LENTO (traducción mientras ejecuta)
5. Errores detectados cuando los encontramos

2.6 Híbridos Modernos: JIT (Just-In-Time)

Compilación JIT: Combina lo mejor de ambos mundos.

Cómo Funciona JIT:

Código Python se interpreta inicialmente
Intérprete detecta código "hot" (ejecutado frecuentemente)
Compila ese código a máquina durante la ejecución
Próximas ejecuciones son rápidas (compiladas)

Ejemplo: PyPy (Python con JIT) es 10-50x más rápido que CPython.

3. Lenguajes de Programación Principales: Análisis Exhaustivo

3.1 JAVA: El Lenguaje Empresarial por Excelencia

Características Fundamentales

Filosofía: "Write Once, Run Anywhere" (WORA)

El código Java se compila a bytecode que ejecuta en cualquier JVM (Java Virtual Machine), independientemente del SO.

Características Clave:

Compilado a Bytecode: Mayor rendimiento que lenguajes puros interpretados
Orientado a Objetos Puro: Todo es objeto (excepto tipos primitivos)
Tipado Estático: Errores detectados en compilación
Gestión Automática de Memoria: Garbage Collector maneja liberar memoria
Multi-threading: Soporte nativo para concurrencia
Rico Ecosistema: Frameworks como Spring, Hibernate, Maven, Gradle

Ejemplo Práctico: Aplicación Hospital SAS

// Estructura típica Java
public class GestorPacientes {
    private String nombre;
    private int edad;
    private List<String> historialMedico;
    
    // Constructor
    public GestorPacientes(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
        this.historialMedico = new ArrayList<>();
    }
    
    // Método public
    public void agregarDiagnostico(String diagnostico) {
        historialMedico.add(diagnostico);
        System.out.println("Diagnóstico agregado para " + nombre);
    }
    
    // Método private
    private boolean esEdadValida() {
        return edad >= 0 && edad <= 150;
    }
    
    // Getters
    public String obtenerNombre() { return nombre; }
    public int obtenerEdad() { return edad; }
    public List<String> obtenerHistorial() { 
        return new ArrayList<>(historialMedico);  // Copia defensiva
    }
}

Compilación y Ejecución Java:

$ javac GestorPacientes.java
↓ Genera: GestorPacientes.class (bytecode)

$ java GestorPacientes
↓ JVM carga y ejecuta el bytecode

Ventajas para SAS:

Estabilidad extrema (usado en 90% sistemas bancarios y sanitarios)
Escalabilidad probada en millones de transacciones
Seguridad robusta (encriptación, permisos)
Rendimiento predecible

Desventajas:

Curva de aprendizaje pronunciada
Verbosidad (mucho código para resultados simples)
Tiempo de inicio lento
Consumo memoria alta

3.2 PYTHON: El Lenguaje de la Inteligencia Artificial y Datos

Características Fundamentales

Filosofía: "Simple es mejor que complejo"

Diseñado para maximizar legibilidad y reducir curva de aprendizaje.

Características Clave:

Lenguaje Interpretado: No requiere compilación previa
Tipado Dinámico: Flexibilidad pero riesgos en ejecución
Sintaxis Clara: Whitespace (sangría) define bloques
Multiparadigma: OOP, Funcional, Procedural
Ecositema Científico: NumPy, SciPy, Pandas, TensorFlow
Comunidad Activa: Librería estándar masiva

Ejemplo Práctico: Análisis de Datos Sanitarios

import pandas as pd
import numpy as np

# Cargar datos de pacientes
df = pd.read_csv("pacientes_sas.csv")

# Análisis simple
edad_promedio = df['edad'].mean()
print(f"Edad promedio: {edad_promedio}")

# Filtrar pacientes con riesgo
riesgo = df[df['tension_arterial'] > 140]
print(f"Pacientes con riesgo: {len(riesgo)}")

# Visualización
import matplotlib.pyplot as plt
df['edad'].hist()
plt.show()

Interpretación Python:

$ python analisis_pacientes.py
↓ Intérprete Python:
  - Lee línea 1: import pandas → carga librería
  - Lee línea 2: import numpy → carga librería
  - Lee línea 5: df = ... → ejecuta lectura CSV
  - ... ejecuta cada línea secuencialmente

Ventajas para SAS:

Desarrollo rapidísimo (prototipado)
Excelente para análisis de datos (Pandas, NumPy)
IA/ML (TensorFlow, PyTorch, Scikit-learn)
Automatización de tareas (scripts)
Legibilidad maximalizada

Desventajas:

Lentitud 10-100x vs Java/C++
Problemas concurrencia (GIL - Global Interpreter Lock)
No apto para sistemas de tiempo real críticos
Distribuir ejecutables complicado

3.3 C# y .NET: La Alternativa Microsoft

Características Fundamentales

Filosofía: "El mejor de Java + mejoras de Microsoft"

Diseñado como respuesta mejorada a Java, con características modernas integradas desde inicio.

Características Clave:

Compilado a IL (Intermediate Language): Similar a bytecode Java
Tipado Estático Fuerte: Seguridad de tipos en compilación
Asincronia Nativa: async/await integrado desde inicio
LINQ: Lenguaje integrado para queries (SQL-like)
Garbage Collection: Gestión automática memoria
.NET Framework/Core: Runtime multiplataforma

Ejemplo Práctico: Aplicación Web SAS

using System;
using System.Linq;

public class RepositorioPacientes {
    private List<Paciente> pacientes;
    
    // Constructor
    public RepositorioPacientes() {
        pacientes = new List<Paciente>();
    }
    
    // Agregar paciente
    public void Agregar(Paciente p) {
        pacientes.Add(p);
        Console.WriteLine($"Paciente {p.Nombre} agregado");
    }
    
    // LINQ: Query integrado en lenguaje
    public List<Paciente> ObtenerMayoresde18() {
        return pacientes
            .Where(p => p.Edad >= 18)
            .OrderBy(p => p.Nombre)
            .ToList();
    }
    
    // Async/Await: Asincronia nativa
    public async Task<bool> GuardarEnBDAsync(Paciente p) {
        try {
            await baseDatos.GuardarAsync(p);
            return true;
        } catch {
            return false;
        }
    }
}

Ventajas para SAS:

Rendimiento cercano a Java
Sintaxis más moderna y limpia que Java
Excelente para aplicaciones web (ASP.NET Core)
Integración natural con ecosistema Microsoft
Asincronia robusta desde inicio

Desventajas:

Históricamente solo Windows (.NET Core ha mejorado)
Menos comunidad que Java
Requiere licencias Microsoft (aunque Core es libre)

4. Lenguajes de Scripting: Automatización Ligera

4.1 Concepto de Scripting

Definición técnica: Lenguajes de scripting son lenguajes interpretados de propósito general optimizados para escribir scripts (pequeños programas) que automatizan tareas, sin necesidad de compilación previa.

4.2 JavaScript: El Lenguaje de la Web

Historia y Propósito Original

Creado en 1995 por Brendan Eich en 2 semanas para Netscape Navigator. Inicialmente pensado solo para navegadores, ahora es ubicuo en web.

Características Clave:

Lenguaje de Navegador: Ejecuta en el cliente (navegador)
Tipado Dinámico: Variables flexibles
Multiparadigma: OOP, Funcional, Procedural
Basado en Prototipos: Herencia diferente a clásica
Callbacks, Promises, Async/Await: Manejo asincronía
Node.js: Ahora también backend (servidor)

Ejemplo: Validación de Formulario Hospital

// Frontend: Validar entrada de datos en tiempo real
document.getElementById('email').addEventListener('blur', function(e) {
    const email = e.target.value;
    
    // Validación cliente (rápida)
    if (!email.includes('@')) {
        alert('Email inválido');
        return;
    }
    
    // Verificar disponibilidad en servidor (async)
    fetch(`/api/verificar-email?email=${email}`)
        .then(response => response.json())
        .then(data => {
            if (data.existe) {
                alert('Email ya registrado');
            } else {
                alert('Email disponible');
            }
        })
        .catch(error => console.error('Error:', error));
});

// Backend: Node.js
const express = require('express');
const app = express();

app.get('/api/verificar-email', async (req, res) => {
    const email = req.query.email;
    const existe = await BaseDatos.buscar('usuarios', { email });
    res.json({ existe });
});

app.listen(3000);

Ventajas:

Ubicuo en web (todos navegadores lo soportan)
Desarrollo full-stack con Node.js
Frameworks: React, Angular, Vue (Frontend)
Comunidad masiva

4.3 Bash/Shell: Administración de Sistemas

Propósito y Uso

Shell de Unix/Linux para automatizar tareas administrativas del sistema operativo.

Ejemplo: Script de Backup Diario SAS

#!/bin/bash
# Script de backup automático para SAS

# Configuración
ORIGEN="/home/sas/bases_datos"
DESTINO="/backups/sas_backup_$(date +%Y%m%d).tar.gz"
LOG_FILE="/var/log/backup_sas.log"

# Crear backup
echo "$(date): Iniciando backup..." >> $LOG_FILE
tar -czf $DESTINO $ORIGEN

# Verificar éxito
if [ $? -eq 0 ]; then
    echo "$(date): Backup exitoso en $DESTINO" >> $LOG_FILE
    # Enviar email de confirmación
    echo "Backup completado" | mail -s "Backup SAS OK" admin@sas.es
else
    echo "$(date): ERROR en backup" >> $LOG_FILE
    # Enviar email de error
    echo "Error en backup" | mail -s "ERROR Backup SAS" admin@sas.es
    exit 1
fi

# Limpiar backups antiguos (>30 días)
find /backups -name "sas_backup_*.tar.gz" -mtime +30 -delete
echo "$(date): Limpieza completada" >> $LOG_FILE

Ejecución Automática:

# Agregar a cron para ejecutar diariamente a las 2 AM
# crontab -e

0 2 * * * /home/sas/scripts/backup.sh

4.4 PHP: El Lenguaje del Servidor Web

Propósito y Evolución

Creado 1995 para aplicaciones web del lado servidor. Ha evolucionado de simple template engine a lenguaje full-featured.

Ejemplo: Portal Pacientes SAS

<?php // portal_pacientes.php session_start(); // Verificar autenticación if (!isset($_SESSION['paciente_id'])) { header('Location: login.php'); exit; } // Conexión BD $pdo = new PDO('mysql:host=localhost;dbname=sas', 'user', 'pass'); // Obtener citas del paciente $stmt = $pdo->prepare( "SELECT * FROM citas WHERE paciente_id = ? ORDER BY fecha DESC" ); $stmt->execute([$_SESSION['paciente_id']]); $citas = $stmt->fetchAll(PDO::FETCH_ASSOC); // Renderizar HTML ?> <!DOCTYPE html> <html> <head><title>Mis Citas - SAS</title></head> <body> <h1>Mis Citas Médicas</h1> <table> <tr><th>Fecha</th><th>Médico</th><th>Especialidad</th></tr> <?php foreach ($citas as $cita): ?> <tr> <td><?= htmlspecialchars($cita['fecha']) ?></td> <td><?= htmlspecialchars($cita['medico']) ?></td> <td><?= htmlspecialchars($cita['especialidad']) ?></td> </tr> <?php endforeach; ?> </table> </body> </html>

5. Entornos de Desarrollo Integrados (IDE): Estado del Arte

5.1 Concepto de IDE

Definición: Software que integra herramientas de desarrollo (editor, compilador, debugger, control versiones) en interfaz única para maximizar productividad del desarrollador.

5.2 IDEs Principales Comparadas

IDE	Lenguajes	Plataformas	Precio	Mejor Para
Visual Studio Code	Todos (extensiones)	Win/Mac/Linux	Gratis	Desarrollo rápido, web, scripting
IntelliJ IDEA	Java, Kotlin, Python	Win/Mac/Linux	Pagado (free community)	Java empresarial, refactorización
Visual Studio 2022	.NET, C++, Python	Win/Mac	Pagado (free community)	Desarrollo .NET/Windows
Eclipse	Java, C++, Python	Win/Mac/Linux	Gratis	Java de propósito general
PyCharm	Python	Win/Mac/Linux	Pagado (free community)	Desarrollo Python puro

5.3 Visual Studio Code: El IDE Moderno

Características Revolucionarias:

Ligero pero Poderoso: Solo 50MB sin dependencias
Extensiones: Miles disponibles para cualquier lenguaje
Integración Git: Nativa
Debug: Soporta múltiples lenguajes
Terminal Integrada: Bash/PowerShell/CMD
IntelliSense: Autocompletado avanzado

Setup típico para Desarrollo SAS (Java):

Extensiones recomendadas:
- Extension Pack for Java (Microsoft)
- Maven for Java (Microsoft)
- Debugger for Java (Microsoft)
- Spring Boot Extension Pack (Pivotal)
- Docker (Microsoft)

Configuración .vscode/settings.json:
{
  "java.configuration.runtimes": [
    {
      "name": "JavaSE-17",
      "path": "/usr/lib/jvm/java-17-openjdk"
    }
  ],
  "java.dependency.packagePresentation": "hierarchical",
  "[java]": {
    "editor.defaultFormatter": "redhat.java",
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.organizeImports": true
    }
  }
}

6. Herramientas de Desarrollo Modernas

6.1 Build Tools (Herramientas de Construcción)

Maven (Java):

Herramienta que automatiza compilación, testing, empaquetamiento, despliegue.

pom.xml (Project Object Model):
<project>
  <groupId>es.sas.salud</groupId>
  <artifactId>sistema-pacientes</artifactId>
  <version>1.0.0</version>
  
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>
</project>

Comando:
$ mvn clean package
↓ Compila, ejecuta tests, genera JAR

6.2 Plataformas de Entrega (CI/CD)

Automatiza: Compilación → Pruebas → Despliegue

Jenkins: Open source, muy flexible, auto-hospedado
GitHub Actions: Integrado en GitHub, gratuito
GitLab CI/CD: Integrado en GitLab
AWS CodePipeline: Servicio AWS

Ejemplo: Pipeline SAS con GitHub Actions

.github/workflows/deploy.yml name: Deploy SAS on: push: branches: [ main ] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up JDK 17 uses: actions/setup-java@v2 with: java-version: '17' - name: Build with Maven run: mvn clean package - name: Run Tests run: mvn test - name: Deploy to Production run: ./scripts/deploy.sh env: DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}

7. Comparativa Final: Selección del Lenguaje Correcto para SAS

Escenario SAS	Lenguaje Recomendado	Justificación
Sistema Información Sanitario Core	Java	Estabilidad, escalabilidad, probado en sistemas críticos
Análisis Datos Pacientes	Python	NumPy, Pandas, ML libraries, desarrollo rápido
Portal Web Pacientes	JavaScript (React) Backend (Java/Node)	Frontend interactivo, backend robusto
Scripts Automatización	Bash/Python	Simplificidad, disponibilidad en servidores
Reportes Médicos	Python + Jinja2	Generación dinámica HTML/PDF
Aplicación Escritorio Médicos	Java Swing / JavaFX / C#	GUI robusta, actualizaciones centralizadas

Con Cuestionario Exhaustivo (25 preguntas) y Mapa Conceptual Detallado para TFA-STI SAS

PARTE 1: CONTENIDOS TEÓRICOS (RESUMEN EJECUTIVO)

1. Traductores: Ensamblador, Compilador, Intérprete

Aspecto	Ensamblador	Compilador	Intérprete
Nivel de Abstracción	Bajo (casi máquina)	Alto (lenguaje natural)	Alto (lenguaje natural)
Entrada	Código Ensamblador	Código Alto Nivel	Código Alto Nivel
Salida	Código Máquina	Código Máquina/Bytecode	Ejecución Directa
Relación Entrada/Salida	1:1 (casi siempre)	1:Muchos	Línea por Línea
Tiempo Ejecución	Inmediato	Inmediato (compilado)	Lento (traducción+ejecución)
Portabilidad	Nula (específico CPU)	Alta (recompilar)	Alta (mismo intérprete)
Errores	Ejecución	Compilación	Ejecución

2. Lenguajes Principales

JAVA: Compilado + Máquina Virtual

Característica clave: Compilado a bytecode que ejecuta en JVM. "Write Once, Run Anywhere".

Uso ideal: Sistemas empresariales, Android, backend escalable.

PYTHON: Interpretado puro

Característica clave: Lenguaje interpretado dinámico. Máxima productividad.

Uso ideal: Data Science, IA, scripts, desarrollo rápido.

C# y .NET: Compilado a IL

Característica clave: Similar a Java pero con características modernas.

Uso ideal: Ecosistema Microsoft, aplicaciones .NET.

Lenguajes Scripting: JavaScript, Bash, PHP

Característica clave: Interpretados, propósito específico, desarrollo rápido.

3. Entornos de Desarrollo Integrados (IDE)

Visual Studio Code, IntelliJ IDEA, Visual Studio, Eclipse, PyCharm.

PARTE 2: CUESTIONARIO EXHAUSTIVO (25 PREGUNTAS)

Pregunta 1: ¿Cuál es la principal diferencia entre un compilador y un intérprete?

A) El compilador es más rápido de escribir

B) El compilador traduce TODO el código antes de ejecutar; el intérprete traduce línea por línea

C) El intérprete solo funciona en Windows

D) No hay diferencia real

Respuesta Correcta: B

El compilador analiza todo el código en fases (léxica, sintáctica, semántica) y genera código máquina/bytecode antes de ejecutar. El intérprete traduce y ejecuta línea por línea en tiempo real.

Pregunta 2: ¿Qué ventaja tiene un ensamblador sobre un compilador?

A) Más fácil de aprender

B) Genera código más eficiente y cercano al hardware

C) Más portabilidad

D) Mejor para desarrollo web

Respuesta Correcta: B

El ensamblador genera código muy eficiente porque tiene relación 1:1 con instrucciones máquina. Permite optimización manual del hardware. Desventaja: no es portable entre diferentes arquitecturas.

Pregunta 3: ¿Qué es bytecode en Java?

A) Código fuente en formato comprimido

B) Código intermedio compilado que ejecuta en cualquier JVM

C) Un error de compilación

D) Código máquina específico de CPU

Respuesta Correcta: B

Java compila a bytecode (.class files) que es independiente de CPU/SO. La JVM en cada máquina interpreta/ejecuta ese bytecode, logrando portabilidad.

Pregunta 4: ¿Cuál es la filosof a de Java "WORA"?

A) Write Only Read Always

B) Write Once, Run Anywhere (Escribe una vez, ejecuta en cualquier lugar)

C) Web Only Runtime Architecture

D) Windows Only Reliability Architecture

Respuesta Correcta: B

WORA significa que código Java compilado a bytecode se ejecuta en cualquier máquina con JVM, sin recompilación.

Pregunta 5: ¿Qué es JIT (Just-In-Time) compilation?

A) Compilación al último momento antes de enviar a producción

B) Compilación durante ejecución de código interpretado para optimizar rendimiento

C) Compilación en navegador web

D) Interpretación de código compilado

Respuesta Correcta: B

JIT compila a máquina durante ejecución el código "hot" (frecuentemente ejecutado), combinando flexibilidad de interpretación con velocidad de compilación.

Pregunta 6: ¿Python es un lenguaje compilado o interpretado?

A) Compilado a bytecode como Java

B) Interpretado puro (sin compilación previa)

C) Ensamblador directo

D) Compilado a máquina nativa

Respuesta Correcta: B

Python es interpretado: el código se traduce y ejecuta línea por línea. Aunque internamente CPython compila a bytecode, lo hace de forma transparente durante ejecución.

Pregunta 7: ¿Cuál es la ventaja principal de Python sobre Java para Data Science?

A) Python es más rápido

B) Python tiene librerías especializadas (NumPy, Pandas, TensorFlow)

C) Java no soporta números

D) Python usa menos memoria

Respuesta Correcta: B

Aunque Python es más lento, tiene ecosistema científico incomparable: NumPy (computación), Pandas (datos), TensorFlow/PyTorch (IA), SciPy (científico).

Pregunta 8: ¿Qué es C# en relación a Java?

A) Una versión mejorada de Java

B) Un lenguaje alternativo similar a Java pero en ecosistema Microsoft

C) Un código de caracteres musicales

D) Una librería de Java

Respuesta Correcta: B

C# es lenguaje compilado a IL, similar conceptualmente a Java pero en ecosistema .NET de Microsoft. Tiene características modernas como async/await desde inicio.

Pregunta 9: ¿Qué son lenguajes de scripting?

A) Lenguajes solo para actores

B) Lenguajes interpretados de propósito específico para automatizar tareas

C) Lenguajes compilados a máquina

D) Solo para interfaces gráficas

Respuesta Correcta: B

Scripts (Bash, Python, JavaScript, PHP) son lenguajes interpretados optimizados para automatizar tareas sin necesidad de compilación previa.

Pregunta 10: ¿Cuál es el uso principal de JavaScript?

A) Programación de servidores solo

B) Programación en navegadores y ahora también servidores (Node.js)

C) Compresión de datos

D) Gestión de bases de datos

Respuesta Correcta: B

JavaScript se ejecuta en navegadores para interactividad frontend. Con Node.js (2009), también se usa en servidor, permitiendo full-stack development.

Pregunta 11: ¿Qué es Bash utilizado principalmente?

A) Desarrollo de aplicaciones móviles

B) Shell de Unix/Linux para automatizar tareas administrativas del sistema

C) Compilador de Java

D) Motor gráficos para videojuegos

Respuesta Correcta: B

Bash (Bourne Again Shell) es shell de Unix/Linux usado para scripts que automatizan tareas del SO: backups, monitoreo, administración de usuarios.

Pregunta 12: ¿Qué es PHP?

A) Un tipo de archivo de imagen

B) Lenguaje interpretado del lado servidor para desarrollo web

C) Protocolo de transferencia de archivos

D) Un nombre de variable en Java

Respuesta Correcta: B

PHP es lenguaje interpretado del lado servidor para generar contenido web dinámico. Se ejecuta en servidor, genera HTML que se envía al cliente.

Pregunta 13: ¿Cuál es la principal característica de Visual Studio Code?

A) Solo soporta Java

B) IDE ligero, gratuito, multiplataforma con soporte múltiples lenguajes via extensiones

C) Solo funciona en Windows

D) Requiere licencia muy cara

Respuesta Correcta: B

VS Code es ligero (~50MB), gratuito, open-source, multiplataforma (Windows/Mac/Linux) con miles de extensiones para cualquier lenguaje.

Pregunta 14: ¿Qué diferencia hay entre IntelliJ IDEA y VS Code?

A) Son idénticos

B) IntelliJ es IDE completo especializado en Java; VS Code es editor ligero multiplataforma

C) IntelliJ solo funciona en Mac

D) VS Code es más caro

Respuesta Correcta: B

IntelliJ IDEA es IDE pesado pero poderoso especializado en Java con análisis avanzado. VS Code es editor ligero y rápido para múltiples lenguajes.

Pregunta 15: ¿Qué es Maven?

A) Un lenguaje de programación

B) Herramienta de automatización de compilación, pruebas y empaquetamiento para Java

C) Un navegador web

D) Un sistema operativo

Respuesta Correcta: B

Maven automatiza compilación, descarga dependencias, ejecuta pruebas y genera empaquetamiento. Usa pom.xml para configuración.

Pregunta 16: ¿Cuáles son las 6 fases principales de compilación?

A) Entrada, Proceso, Salida, Verificación, Almacenamiento, Distribución

B) Léxica, Sintáctica, Semántica, Intermedia, Optimización, Código Máquina

C) Análisis, Diseño, Codificación, Pruebas, Despliegue, Mantenimiento

D) No hay fases definidas

Respuesta Correcta: B

Un compilador realiza: 1) Análisis Léxico (tokenización), 2) Sintáctico (parsing), 3) Semántico (validación), 4) Generación Código Intermedio, 5) Optimización, 6) Generación Código Máquina.

Pregunta 17: ¿Qué es tipado estático versus dinámico?

A) Lo mismo, solo nombres diferentes

B) Estático: tipos checados compilación (Java); Dinámico: tipos checados ejecución (Python)

C) Dinámico es mejor en todos casos

D) Solo existe uno de ellos

Respuesta Correcta: B

Tipado Estático (Java, C#): errores de tipo detectados en compilación. Tipado Dinámico (Python, JavaScript): errores detectados en ejecución.

Pregunta 18: ¿Cuál es la portabilidad de Java vs Python?

A) Java no es portable; Python es totalmente portable

B) Ambos requieren recompilar para cada SO

C) Ambos son portables: Java vía bytecode+JVM; Python vía intérprete Python en cada SO

D) Ninguno es portable

Respuesta Correcta: C

Java: bytecode portátil ejecuta en cualquier JVM. Python: código portátil ejecuta en Python instalado. Ambos requieren runtime/intérprete en máquina destino.

Pregunta 19: ¿Qué ventaja tiene TypeScript sobre JavaScript?

A) Es más rápido de ejecutar

B) Agrega tipado estático a JavaScript para detectar errores compilación

C) Funciona solo en navegadores

D) Es más difícil de aprender

Respuesta Correcta: B

TypeScript es superset de JavaScript que agrega tipos estáticos. Se compila a JavaScript. Detecta errores en tiempo compilación, mejorando calidad código.

Pregunta 20: ¿Qué es un IDE?

A) Un virus informático

B) Integrated Development Environment: herramientas integradas (editor, compilador, debugger)

C) Un tipo de base de datos

D) Protocolo de red

Respuesta Correcta: B

IDE integra en una interfaz: editor de código, compilador/intérprete, debugger, control versiones, todo para maximizar productividad.

Pregunta 21: ¿Cuál es el mejor lenguaje para un sistema de salud como SAS?

A) Solo Python

B) Solo JavaScript

C) Multilenguaje: Java backend, Python data, JavaScript frontend

D) Cualquiera, son todos iguales

Respuesta Correcta: C

Sistema SAS integral usaría: Java para backend escalable/seguro, Python para análisis datos/IA, JavaScript para frontend web interactivo.

Pregunta 22: ¿Qué es CI/CD?

A) Compact Disc/Digital Video

B) Continuous Integration/Continuous Deployment: automatizar build, test, deploy

C) Un tipo de código postal

D) Compresión de datos

Respuesta Correcta: B

CI/CD automatiza: Continuous Integration (compilar+test frecuente) y Continuous Deployment (desplegar automáticamente si tests pasan).

Pregunta 23: ¿Qué es Garbage Collection en Java?

A) Eliminación de código innecesario

B) Recolección automática de memoria no usada

C) Limpieza de caché

D) Borradura de archivos temporales

Respuesta Correcta: B

Garbage Collector de Java automáticamente detecta y libera memoria de objetos no referenciados, evitando memory leaks.

Pregunta 24: ¿Cuál es la principal diferencia entre .NET Framework y .NET Core?

A) No hay diferencia

B) Framework solo Windows; Core es multiplataforma (Windows/Mac/Linux)

C) Framework es gratuito; Core es pagado

D) Core es antiguo; Framework es moderno

Respuesta Correcta: B

.NET Framework fue solo Windows históricamente. .NET Core (ahora .NET 5+) es multiplataforma, open source, gratis.

Pregunta 25: ¿Cuáles son los criterios para elegir un lenguaje de programación?

A) Velocidad de desarrollo, rendimiento, comunidad, ecosistema, mantenibilidad

B) Solo velocidad de compilación

C) Solo popularidad

D) El primero que encuentres

Respuesta Correcta: A

Criterios para elegir lenguaje: 1) Velocidad desarrollo, 2) Rendimiento requerido, 3) Tamaño comunidad, 4) Ecosistema librerías, 5) Mantenibilidad largo plazo.

PARTE 3: MAPA CONCEPTUAL EXHAUSTIVO

Visualización Jerárquica de Tema 46

TEMA 46: LENGUAJES DE PROGRAMACIÓN
═══════════════════════════════════════════════════════════════════════════════

1. JERARQUÍA DE LENGUAJES
─────────────────────────────────────────────────────────────────────────────

    NIVEL 5: LENGUAJES ALTO NIVEL (Más abstractos, legibles)
    │
    ├─→ Lenguajes Compilados
    │   ├─ Java (Compilado → Bytecode → JVM)
    │   ├─ C++ (Compilado → Máquina nativa)
    │   ├─ C# (Compilado → IL → .NET Runtime)
    │   └─ Go (Compilado → Máquina nativa)
    │
    ├─→ Lenguajes Interpretados
    │   ├─ Python (Interpretado puro, dinámico)
    │   ├─ JavaScript (Interpretado, navegadores + Node.js)
    │   ├─ Ruby (Interpretado dinámico)
    │   └─ PHP (Interpretado servidor web)
    │
    └─→ Lenguajes Scripting
        ├─ Bash/Shell (Automatización SO)
        ├─ Python (Multiuso: scripts + desarrollo)
        ├─ JavaScript (Frontend interactivo)
        └─ PowerShell (Windows automation)
    
    NIVEL 4: LENGUAJES INTERMEDIOS
    │
    ├─→ Bytecode (Máquina Virtual)
    │   ├─ Java Bytecode (.class ejecuta en JVM)
    │   ├─ .NET IL (Intermediate Language ejecuta en .NET Runtime)
    │   └─ Python Bytecode (interno CPython)
    
    NIVEL 3: LENGUAJE ENSAMBLADOR
    │
    └─→ Mnemonics para operaciones máquina
        ├─ x86 Assembly (Intel/AMD)
        ├─ ARM Assembly (Móviles/Embedded)
        ├─ MIPS Assembly (Routers/Legacy)
        └─ PowerPC Assembly (Hardware específico)
    
    NIVEL 1-2: CÓDIGO MÁQUINA (Más bajo, específico CPU)
    │
    └─→ Binario puro (10110101 11000101 ...)
        └─ Específico de arquitectura CPU


2. TRADUCTORES: HERRAMIENTAS CRÍTICAS
─────────────────────────────────────────────────────────────────────────────

    ENSAMBLADOR
    ├─ Entrada: Código Ensamblador (MOV AX, 5)
    ├─ Salida: Código Máquina binario
    ├─ Relación: 1:1 casi siempre
    ├─ Tiempo Ejecución: Inmediato (ya binario)
    ├─ Portabilidad: NULA (específico CPU)
    ├─ Complejidad: Baja
    ├─ Detección Errores: Ejecución
    └─ Ventaja: Máxima eficiencia, control total hardware
    
    COMPILADOR
    ├─ Entrada: Código Alto Nivel (int x = 5 + 3;)
    ├─ Salida: Código Máquina o Bytecode
    ├─ Relación: 1 línea → Muchas líneas código máquina
    ├─ Proceso: 6 Fases
    │   ├─ 1) Análisis Léxico (tokenización)
    │   ├─ 2) Análisis Sintáctico (parsing, AST)
    │   ├─ 3) Análisis Semántico (validación tipos)
    │   ├─ 4) Generación Código Intermedio
    │   ├─ 5) Optimización (folding, inlining)
    │   └─ 6) Generación Código Máquina/Bytecode
    ├─ Tiempo Ejecución: Inmediato (pre-compilado)
    ├─ Portabilidad: ALTA (recompilar)
    ├─ Complejidad: Muy Alta
    ├─ Detección Errores: Compilación
    └─ Ventaja: Rápido ejecución, errores detectados antes
    
    INTÉRPRETE
    ├─ Entrada: Código Alto Nivel (x = 5 + 3)
    ├─ Salida: Ejecución Directa
    ├─ Relación: Línea por línea
    ├─ Proceso: Traducción Dinámica
    │   ├─ Lee línea
    │   ├─ Traduce
    │   └─ Ejecuta inmediatamente
    ├─ Tiempo Ejecución: Lento (traducción+ejecución)
    ├─ Portabilidad: ALTA (mismo intérprete en destino)
    ├─ Complejidad: Alta
    ├─ Detección Errores: Ejecución
    └─ Ventaja: Flexibilidad, desarrollo rápido, no requiere compilación
    
    HÍBRIDO: JIT (Just-In-Time)
    ├─ Combina: Interpretación + Compilación
    ├─ Funcionamiento:
    │   ├─ Interpreta inicialmente
    │   ├─ Detecta código "hot" (frecuente)
    │   ├─ Compila a máquina durante ejecución
    │   └─ Próximas ejecuciones: rápidas (compiladas)
    ├─ Ejemplo: PyPy (10-50x más rápido que CPython)
    └─ Ventaja: Balance velocidad + flexibilidad


3. LENGUAJES PRINCIPALES: CARACTERÍSTICAS Y APLICACIONES
─────────────────────────────────────────────────────────────────────────────

    JAVA
    ├─ Tipo: Compilado → Bytecode → JVM
    ├─ Paradigma: OOP Puro
    ├─ Tipado: Estático Fuerte
    ├─ Portabilidad: "Write Once, Run Anywhere" (WORA)
    ├─ Memoria: Garbage Collection automático
    ├─ Concurrencia: Multi-threading nativo
    ├─ Ecosistema: Spring, Hibernate, Maven, Gradle
    ├─ Comunidad: Masiva, bien documentado
    ├─ Performance: Alto
    ├─ Curva Aprendizaje: Pronunciada (verbose)
    ├─ Aplicaciones:
    │   ├─ Sistemas empresariales críticos
    │   ├─ Backend escalable (millones usuarios)
    │   ├─ Aplicaciones Android
    │   └─ Big Data (Hadoop, Spark)
    └─ Ideal para SAS: Core Backend sistemas sanitarios

    PYTHON
    ├─ Tipo: Interpretado puro (dinámico)
    ├─ Paradigma: Multiparadigma (OOP, Funcional, Procedural)
    ├─ Tipado: Dinámico (flexible pero riesgos)
    ├─ Portabilidad: Alta (intérprete en destino)
    ├─ Memoria: Garbage Collection automático
    ├─ Sintaxis: Simple, legible, clara
    ├─ Ecosistema: NumPy, Pandas, TensorFlow, PyTorch, SciPy
    ├─ Comunidad: Masiva, especialmente Data Science/IA
    ├─ Performance: Moderado (lento vs Java/C++)
    ├─ Curva Aprendizaje: Suave (uno de los más fáciles)
    ├─ Aplicaciones:
    │   ├─ Data Science y Análisis
    │   ├─ Machine Learning e IA
    │   ├─ Scripts y Automatización
    │   ├─ Web con Django/Flask
    │   ├─ Computación científica
    │   └─ Prototipado rápido
    └─ Ideal para SAS: Análisis datos pacientes, IA/ML

    C# / .NET
    ├─ Tipo: Compilado → IL → .NET Runtime
    ├─ Paradigma: OOP (como Java)
    ├─ Tipado: Estático Fuerte
    ├─ Portabilidad: .NET Framework (Windows) / .NET Core (multiplataforma)
    ├─ Características Modernas: async/await, LINQ, nullable types
    ├─ Ecosistema: ASP.NET Core, Entity Framework, Visual Studio
    ├─ Performance: Muy Alto (cercano Java)
    ├─ Aplicaciones:
    │   ├─ Aplicaciones Web ASP.NET Core
    │   ├─ Desktop Windows
    │   ├─ Juegos (Unity C#)
    │   └─ Sistemas Microsoft-centric
    └─ Ideal para SAS: Si integración Microsoft requerida

    JAVASCRIPT
    ├─ Tipo: Interpretado (navegadores) / JIT (Node.js)
    ├─ Creación: 1995 (Brendan Eich, 2 semanas!)
    ├─ Paradigma: Multiparadigma (OOP, Funcional)
    ├─ Tipado: Dinámico
    ├─ Contextos:
    │   ├─ Frontend: Navegadores (todas soportan)
    │   └─ Backend: Node.js (desde 2009)
    ├─ Frameworks Frontend: React, Angular, Vue
    ├─ Frameworks Backend: Express, NestJS, Next.js
    ├─ Características: Callbacks, Promises, Async/Await
    ├─ Aplicaciones:
    │   ├─ Interactividad web
    │   ├─ Full-stack development
    │   ├─ Aplicaciones web progresivas (PWA)
    │   └─ Desarrollo multiplataforma (Electron)
    └─ Ideal para SAS: Frontend web interactivo

    BASH/SHELL
    ├─ Tipo: Interpretado (scripting)
    ├─ Contexto: Unix/Linux scripting
    ├─ Aplicaciones:
    │   ├─ Automatización tareas SO
    │   ├─ Backups programados (cron)
    │   ├─ Monitoreo sistemas
    │   ├─ Gestión servidores
    │   └─ Pipelines datos
    └─ Ideal para SAS: Scripts admininstración servidores

    PHP
    ├─ Tipo: Interpretado servidor web
    ├─ Contexto: Desarrollo web backend
    ├─ Aplicaciones:
    │   ├─ Portales web dinámicos
    │   ├─ Aplicaciones CRUD
    │   ├─ Gestión contenido
    │   └─ Integración BD
    └─ Ideal para SAS: Portales pacientes web


4. ENTORNOS DE DESARROLLO INTEGRADOS (IDE)
─────────────────────────────────────────────────────────────────────────────

    VISUAL STUDIO CODE
    ├─ Tipo: Editor + IDE Ligero
    ├─ Tamaño: 50MB (sin dependencias)
    ├─ Precio: Gratuito, Open Source
    ├─ Plataformas: Win/Mac/Linux
    ├─ Lenguajes: Todos (extensiones)
    ├─ Fortalezas:
    │   ├─ Ligero y rápido
    │   ├─ Miles extensiones
    │   ├─ Integración Git nativa
    │   ├─ Terminal integrada
    │   └─ IntelliSense avanzado
    └─ Ideal: Desarrollo rápido, web, scripting

    INTELLIJ IDEA
    ├─ Tipo: IDE Completo Professional
    ├─ Precio: Pagado (Community Edition gratis)
    ├─ Plataformas: Win/Mac/Linux
    ├─ Lenguajes: Java, Kotlin, Python
    ├─ Fortalezas:
    │   ├─ Análisis código inteligente
    │   ├─ Refactorización avanzada
    │   ├─ Debugging robusto
    │   └─ Herramientas enterprise
    └─ Ideal: Desarrollo Java profesional

    VISUAL STUDIO 2022
    ├─ Tipo: IDE Completo Enterprise Microsoft
    ├─ Precio: Pagado (Community Edition gratis)
    ├─ Plataformas: Win/Mac
    ├─ Lenguajes: .NET, C++, Python
    ├─ Fortalezas:
    │   ├─ Integración Azure
    │   ├─ Herramientas Windows
    │   ├─ Debugging avanzado
    │   └─ Análisis rendimiento
    └─ Ideal: Ecosistema Microsoft

    PYCHARM
    ├─ Tipo: IDE Especializado Python
    ├─ Precio: Pagado (Community gratis)
    ├─ Fortalezas: Python puro, Scientific tools, Data inspection
    └─ Ideal: Desarrollo Python Data Science

    ECLIPSE
    ├─ Tipo: IDE Completo Open Source
    ├─ Precio: Gratuito
    ├─ Lenguajes: Java, C++, Python
    └─ Ideal: Java de propósito general


5. HERRAMIENTAS CONSTRUCCIÓN Y DESPLIEGUE
─────────────────────────────────────────────────────────────────────────────

    BUILD TOOLS
    ├─ Maven (Java)
    │   ├─ Automatiza: Compilación, Tests, Empaquetamiento
    │   ├─ Configuración: pom.xml
    │   └─ Comandos: mvn clean package
    │
    ├─ Gradle (Java/Android)
    │   ├─ Build script: build.gradle (Groovy/Kotlin)
    │   └─ Características: Flexible, plugin-based
    │
    ├─ npm (Node.js/JavaScript)
    │   ├─ Gestor paquetes y build tool
    │   ├─ Configuración: package.json
    │   └─ Comandos: npm install, npm run build
    │
    └─ pip (Python)
        ├─ Gestor paquetes Python
        └─ Comandos: pip install, pip freeze

    CI/CD PLATFORMS
    ├─ GitHub Actions: Integrado GitHub (gratuito)
    ├─ GitLab CI/CD: Integrado GitLab
    ├─ Jenkins: Self-hosted, muy flexible
    └─ AWS CodePipeline: Servicio AWS

    WORKFLOW CI/CD TÍPICO
    ├─ 1) Developer hace push a repositorio
    ├─ 2) Hook dispara pipeline
    ├─ 3) Checkout código
    ├─ 4) Instalar dependencias
    ├─ 5) Compilar/Build
    ├─ 6) Ejecutar tests automatizados
    ├─ 7) Si tests pasan: Despliegue automático
    ├─ 8) Si tests fallan: Notificar desarrollador
    └─ Resultado: Rapidez + Calidad asegurada


6. SELECCIÓN LENGUAJE: MATRIZ DE DECISIÓN
─────────────────────────────────────────────────────────────────────────────

    Escenario                          → Lenguaje Recomendado
    ─────────────────────────────────────────────────────────
    Backend sistema crítico            → Java (estable, escalable)
    Análisis datos pacientes           → Python (NumPy, Pandas)
    Machine Learning/IA sanitaria      → Python (TensorFlow, PyTorch)
    Portal web pacientes               → JavaScript (React) + Backend
    Scripts administrativos            → Bash/Python
    Reportes PDF médicos               → Python (Jinja2, ReportLab)
    Aplicación escritorio médicos      → Java/C#
    Servicios web RESTful              → Java/Python/Node.js
    Integración datos tiempo real      → Java/C#
    Prototipado rápido                 → Python
    Computación científica             → Python + NumPy/SciPy


7. CRITERIOS EVALUACIÓN LENGUAJES
─────────────────────────────────────────────────────────────────────────────

    Para elegir lenguaje correcto en SAS:
    
    ✓ Velocidad Desarrollo: Python > JavaScript > Java (tiempo inicial)
    ✓ Rendimiento: C++ > Java > C# > Python (velocidad ejecución)
    ✓ Comunidad: Java > Python > JavaScript > Others (soporte)
    ✓ Ecosistema: Python (Data) > Java (Enterprise) > Others
    ✓ Mantenibilidad: Java > C# > Python (tipos estáticos ayudan)
    ✓ Escalabilidad: Java ≈ C# >> Python (concurrencia)
    ✓ Seguridad: Java > C# > Python (tipos + frameworks)
    ✓ Curva Aprendizaje: Python < JavaScript < Java (facilidad)
    
    RECOMENDACIÓN INTEGRAL SAS:
    ├─ Backend Principal: JAVA (confiabilidad crítica)
    ├─ Data/IA: PYTHON (mejor herramientas)
    ├─ Frontend Web: JAVASCRIPT/React (interactividad)
    ├─ Scripts Admin: BASH/Python (automatización)
    └─ Integración: APIs REST (cualquier lenguaje)


═══════════════════════════════════════════════════════════════════════════════

Tabla Resumen: Mapa Conceptual Estructurado

COMPONENTE PRINCIPAL	SUBCOMPONENTES	CARACTERÍSTICAS CLAVE	APLICACIÓN SAS
TRADUCTORES	Ensamblador, Compilador, Intérprete, JIT	Herramientas críticas que permiten ejecutar código	Seleccionar según lenguaje elegido
LENGUAJES COMPILADOS	Java, C++, C#, Go	Rápidos, seguros, verificación tipos compilación	Backend sistemas críticos
LENGUAJES INTERPRETADOS	Python, JavaScript, Ruby, PHP	Flexibles, dinámicos, desarrollo rápido	Scripting, análisis, frontend web
JAVA ESPECÍFICO	Bytecode, JVM, GC, WORA	Máxima confiabilidad, escalabilidad	Core sistema información SAS
PYTHON ESPECÍFICO	NumPy, Pandas, TensorFlow, SciPy	Ecosistema Data Science/IA incomparable	Análisis datos, ML, predicciones médicas
JAVASCRIPT	Frontend (React), Backend (Node.js)	Ubicuo en web, full-stack development	Portales web pacientes interactivos
SCRIPTING	Bash, Python, PHP	Automatización, propósito específico	Backups, monitoreo, portales web
ENTORNOS DESARROLLO	VS Code, IntelliJ, Visual Studio, PyCharm, Eclipse	Herramientas integradas para máxima productividad	Seleccionar según lenguaje/preferencia
HERRAMIENTAS BUILD	Maven, Gradle, npm, pip	Automatizan compilación, testing, empaquetamiento	Pipeline automatizado SAS
CI/CD	GitHub Actions, Jenkins, GitLab CI	Automatización completa build → test → deploy	Despliegue continuo sistemas SAS