Fundamentos de Informática (100 horas) – Enfoque en niveles básicos de abstracción (hardware y lógica binaria)

  • Introducción a la informática: historia, evolución y aplicaciones modernas (10 horas).

Elementos históricos: 1822 – Máquina diferencial de Charles Babbage (primer concepto de calculadora mecánica); 1936 – Máquina de Turing de Alan Turing (modelo teórico de computación); 1945 – ENIAC (Electronic Numerical Integrator and Computer) de John Mauchly y J. Presper Eckert (primer computador electrónico general); hasta los 2020s – IA y computación cuántica.

  • Componentes hardware: CPU, memoria, storage y periféricos (10 horas).

Elementos históricos: 1947 – Transistor inventado por William Shockley, John Bardeen y Walter Brattain en Bell Labs (base para la electrónica moderna); 1958 – Circuito integrado (IC) de Jack Kilby (Texas Instruments); 1971 – Microprocesador Intel 4004 (primer CPU en chip único); 1969 – Nova de Data General (DG, minicomputador influyente); hasta 2023 – Procesadores ARM y GPU NVIDIA para IA.

  • Software de base: sistemas operativos, utilidades e interfaces de usuario (10 horas).

Elementos históricos: 1951 – UNIVAC I (Universal Automatic Computer) con primeros software de sistema; 1969 – UNIX de Ken Thompson y Dennis Ritchie (Bell Labs, base para OS modernos); 1981 – MS-DOS (Microsoft Disk Operating System); 1970 – PDP-11 de DEC (Digital Equipment Corporation, minicomputador clave para desarrollo de UNIX); hasta los 2020s – Kernel Linux y Windows 11.

  • Programación introductoria: conceptos de algoritmos, variables y estructuras de control en Python (15 horas).

Elementos históricos: 1843 – Algoritmo de Ada Lovelace para la máquina analítica (primer programa); 1940s – Lógica binaria y matemática booleana de George Boole (1854, base para circuitos digitales); 1950s – Primeros lenguajes assembly (código máquina binario); hasta 1989 – Python de Guido van Rossum.

  • Lógica y resolución de problemas: álgebra booleana, diagramas de flujo y depuración simple (10 horas).

Elementos históricos: 1847 – Álgebra booleana formalizada por George Boole; 1940s – Tarjetas perforadas usadas en IBM 701 (primer computador comercial, 1952); 1950s – Depuración introducida por Grace Hopper (pionera de COBOL); hasta los 2020s – Herramientas como depuradores en IDE modernos.

  • Matemática para la informática: bases de conjuntos, funciones y grafos (10 horas).

Elementos históricos: 1879 – Teoría de conjuntos de Georg Cantor; 1930s – Teoría de grafos de Leonhard Euler (1736, puente de Königsberg); 1940s – Aplicaciones en ENIAC; hasta 2023 – Grafos en algoritmos de machine learning.

  • Uso práctico del computador: gestión de archivos, editores de texto y herramientas de productividad (10 horas).

Elementos históricos: 1890 – Tarjetas perforadas de Herman Hollerith (para censo USA, base para IBM); 1960s – Sistema de archivos en Multics (precursor de UNIX); 1981 – Xerox Star (primer sistema con interfaz gráfica de usuario, GUI, en Xerox PARC); hasta los 2020s – Almacenamiento en nube como Google Drive.

  • Introducción a la red: conceptos base de internet y navegación web segura (10 horas).

Elementos históricos: 1969 – ARPANET (primer red de conmutación de paquetes, DARPA); 1989 – World Wide Web de Tim Berners-Lee (CERN); hasta 2023 – Protocolos HTTPS e IPv6.

  • Ejercicios prácticos: pequeños scripts y simulaciones hardware (10 horas).

Elementos históricos: 1940s – Simulaciones en Colossus (computador británico para criptoanálisis); hasta los 2020s – Simuladores como QEMU para hardware virtual.

  • Evaluación: tests y proyectos iniciales (5 horas).

Elementos históricos: 1950s – Primeros benchmarks en IBM 704; hasta hoy – Evaluaciones con GitHub para portafolios.

Programación y Estructuras de Datos (100 horas) – Enfoque en niveles intermedios de codificación (lenguajes assembly y de alto nivel, bases de datos)

  • Programación intermedia: funciones, módulos y librerías en Python (15 horas).

Elementos históricos: 1949 – Lenguaje assembly en EDSAC (Electronic Delay Storage Automatic Calculator, Cambridge); 1957 – FORTRAN (Formula Translation) de John Backus (IBM, primer lenguaje de alto nivel); hasta 2023 – Librerías Python como NumPy.

  • Estructuras de datos de base: arrays, listas enlazadas, pilas y colas (15 horas).

Elementos históricos: 1950s – Arrays en FORTRAN; 1960s – Listas enlazadas en LISP de John McCarthy (1958, MIT); hasta los 2020s – Estructuras en Java y C++.

  • Algoritmos fundamentales: búsqueda lineal/binaria y ordenamiento (bubble, quicksort) (15 horas).

Elementos históricos: 1950s – Bubble sort descrito por John von Neumann; 1960 – Quicksort de Tony Hoare; hasta 2023 – Algoritmos optimizados en bibliotecas estándar.

  • Complejidad computacional: notación Big O y análisis de eficiencia (10 horas).

Elementos históricos: 1965 – Complejidad temporal formalizada por Juris Hartmanis y Richard Stearns (Premio Turing); hasta los 2020s – Aplicaciones en big data.

  • Introducción a las bases de datos: modelos relacionales, normalización y diseño ER (10 horas).

Elementos históricos: 1970 – Modelo relacional de Edgar F. Codd (IBM); 1974 – System R (primer DBMS relacional); 1988 – AS/400 de IBM (sistema midrange con base de datos integrada); hasta 2023 – NoSQL como MongoDB.

  • Consultas SQL: SELECT, INSERT, UPDATE, DELETE y joins simples (15 horas).

Elementos históricos: 1974 – SQL (Structured Query Language) desarrollado por Donald Chamberlin y Raymond Boyce (IBM); hasta los 2020s – SQL en PostgreSQL y MySQL.

  • Bases de datos prácticas: instalación de SQLite/MySQL y ejercicios con datos reales (10 horas).

Elementos históricos: 1986 – Precursores de SQLite en dBase; 1995 – MySQL de Michael Widenius; hasta hoy – DB en nube como AWS RDS.

  • Depuración y testing: unit tests y gestión de errores (5 horas).

Elementos históricos: 1947 – “Bug” acuñado por Grace Hopper (polilla en relé); 1970s – Unit testing en Smalltalk; hasta 2023 – Frameworks como pytest.

  • Proyectos: implementación de una aplicación con datos estructurados (5 horas).

Elementos históricos: 1960s – Aplicaciones en CDC 6600 (Control Data Corporation, primer supercomputador, 1964); hasta hoy – Proyectos open-source en GitHub.

Sistemas, Redes y Seguridad (100 horas) – Enfoque en niveles de sistema y red (OS, protocolos, seguridad)

  • Sistemas operativos: procesos, hilos, gestión de memoria y scheduling (15 horas).

Elementos históricos: 1961 – CTSS (Compatible Time-Sharing System, MIT); 1969 – UNIX; hasta 2023 – Multihilos en Linux y Windows.

  • Sistema de archivos y storage: estructuras, permisos y backups (10 horas).

Elementos históricos: 1956 – Disco rígido IBM 350 (primer HDD); 1960s – FAT (File Allocation Table); hasta los 2020s – SSD y NTFS.

  • Redes informáticas: modelos OSI/TCP-IP, protocolos HTTP, FTP y DNS (15 horas).

Elementos históricos: 1974 – TCP/IP de Vint Cerf y Bob Kahn; 1981 – Modelo OSI (Open Systems Interconnection, ISO); 1970s – Terminales 3270 de IBM (para mainframes, acceso remoto); hasta 2023 – HTTP/3.

  • Configuración de redes: LAN, WAN, routers y switches base (10 horas).

Elementos históricos: 1970 – Ethernet de Robert Metcalfe (Xerox PARC); 1980s – Routers Cisco; hasta hoy – Wi-Fi 6 y 5G.

  • Seguridad informática: criptografía simétrica/asimétrica y certificados (10 horas).

Elementos históricos: 1976 – Intercambio de claves Diffie-Hellman; 1977 – RSA (Rivest-Shamir-Adleman); hasta 2023 – Criptografía post-cuántica.

  • Amenazas y defensas: virus, firewalls, autenticación y privacidad de datos (10 horas).

Elementos históricos: 1971 – Virus Creeper (primero); 1988 – Gusano Morris; hasta 2023 – Ransomware como WannaCry.

  • Desarrollo web base: HTML5, CSS3 y JavaScript para interfaces interactivas (10 horas).

Elementos históricos: 1991 – HTML de Tim Berners-Lee; 1995 – JavaScript de Brendan Eich (Netscape); hasta 2023 – Estándar HTML5.

  • Backend web: introducción a frameworks como Flask/Django (10 horas).

Elementos históricos: 1995 – PHP de Rasmus Lerdorf; 2005 – Django; hasta hoy – Node.js (2009).

  • Ejercicios prácticos: configuración de una red local y tests de seguridad (5 horas).

Elementos históricos: 1980s – Primeras LAN Ethernet; hasta los 2020s – Simulaciones con Wireshark.

  • Evaluación: simulaciones y reportes sobre vulnerabilidades (5 horas).

Elementos históricos: 1990s – CERT (Computer Emergency Response Team); hasta hoy – Pruebas de penetración.

Aplicaciones Avanzadas y Proyectos (100 horas) – Enfoque en niveles avanzados (IA, cloud, futuro)

  • Inteligencia artificial: machine learning base, regresión y clasificación (15 horas).

Elementos históricos: 1956 – Conferencia de Dartmouth (nacimiento de IA, John McCarthy); 1959 – Perceptrón de Frank Rosenblatt; hasta 2023 – Transformers en modelos GPT.

  • Redes neuronales: conceptos introductorios con librerías como TensorFlow (10 horas).

Elementos históricos: 1986 – Backpropagation de Rumelhart; 2012 – AlexNet (boom de deep learning); hasta 2023 – TensorFlow (2015, Google).

  • Desarrollo software avanzado: metodologías Agile/Scrum y control de versiones con Git (12 horas).

Elementos históricos: 2001 – Manifiesto Agile; 2005 – Git de Linus Torvalds; 1975 – “The Mythical Man-Month” de Frederick Brooks (problemas en gestión de proyectos software); hasta hoy – DevOps.

  • Cloud computing: servicios AWS/Azure, virtualización y contenedores (10 horas).

Elementos históricos: 1960s – Virtualización en IBM CP-40; 2006 – AWS EC2; hasta 2023 – Kubernetes (2014).

  • Big data y analytics: introducción a Hadoop y tools como Pandas (10 horas).

Elementos históricos: 2006 – Hadoop de Doug Cutting (Yahoo); hasta 2023 – Spark (2009).

  • Aplicaciones móviles: bases de desarrollo Android/iOS (10 horas).

Elementos históricos: 2007 – iPhone OS (ahora iOS); 2008 – Android de Google; hasta hoy – Flutter (2017).

  • Ética informática: impacto social, privacidad y bias en IA (3 horas).

Elementos históricos: 1940s – Código de Núremberg para ética; 2018 – GDPR; hasta 2023 – Guías éticas de IA.

  • Tendencias futuras: blockchain, IoT y computación cuántica (5 horas).

Elementos históricos: 2008 – Bitcoin de Satoshi Nakamoto (blockchain); 1999 – IoT acuñado por Kevin Ashton; 1982 – Computación cuántica de Richard Feynman; hasta 2025 – Qubits escalables (ej. IBM Quantum).

  • Proyectos finales: desarrollo de una aplicación completa en equipo (20 horas).

Elementos históricos: 1960s – Proyectos en Apollo Guidance Computer; hasta hoy – Colaborativos open-source.

  • Evaluación: presentaciones, revisiones de código y portafolios (5 horas).

Elementos históricos: 1990s – Revisión de código en Microsoft; hasta hoy – Portafolios en GitHub.