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.