## GRAPH NAME
```
LENGUAJES PROGRAMACION
```

***

***
## NODO 1
**NAME**
```
ADA LOVELACE NOTE
```

**DATE**
```
1843
```

**PLACE**

**WHO**
```
Ada Lovelace
```

**BRIEF DESCRIPTION**
La "Note G" de Ada Lovelace (1843), adjunta a su traducción del artículo de Menabrea sobre la Máquina Analítica de Babbage, describe el primer algoritmo destinado a ser procesado por una máquina, para calcular los números de Bernoulli. Es el punto de origen histórico de la programación como disciplina conceptual, sin implementación física disponible.[1][2][3][4][5]

**LINK**
```
https://en.wikipedia.org/wiki/Ada_Lovelace
https://en.wikipedia.org/wiki/Timeline_of_programming_languages
```

***
## NODO 2
**NAME**
```
PLANKALKUL 1943
```

**DATE**
```
1943
```

**PLACE**
```
Germany - Berlin
```

**WHO**
```
Konrad Zuse
```

**BRIEF DESCRIPTION**
Plankalkül (1943–1945, publicado 1948) es el primer lenguaje de programación de alto nivel para computadora electrónica, diseñado por Konrad Zuse para el ordenador Z4. Incluía estructuras de datos, bucles condicionales y subrutinas. Su diseño fue tan avanzado que influyó en ALGOL décadas después, aunque no fue implementado hasta 1975.[1][2][3][4][5]

**LINK**
```
https://en.wikipedia.org/wiki/Plankalk%C3%BCl
```

***
## NODO 3
**NAME**
```
ENIAC SHORT CODE
```

**DATE**
```
1946
```

**PLACE**
```
USA - Pennsylvania - Philadelphia
```

**WHO**
```
Richard Clippinger; John von Neumann (after Alan Turing)
```

**BRIEF DESCRIPTION**
El ENIAC Coding System (1946) fue el primer sistema de instrucciones para una computadora electrónica de propósito general. Short Code (1949), desarrollado por Mauchly, fue el primer lenguaje de alto nivel real implementado, permitiendo al programador escribir expresiones matemáticas en lugar de código binario puro. Precede directamente al lenguaje ensamblador simbólico.[1][3][4][5]

**LINK**
```
https://en.wikipedia.org/wiki/Short_Code_(computer_language)
```

***
## NODO 4
**NAME**
```
ASSEMBLY LANG 1949
```

**DATE**
```
1949
```

**PLACE**
```
UK - England - Cambridge
```

**WHO**
```
David Wheeler; Kathleen Booth; Maurice Wilkes (EDSAC)
```

**BRIEF DESCRIPTION**
El lenguaje ensamblador emergió entre 1947 y 1952 con desarrollos paralelos en EDSAC (Wheeler, 1949), UNIVAC y Manchester Mark I. Reemplaza código binario con nemónicos simbólicos (MOV, ADD, JMP), creando una capa de abstracción humana sobre el hardware. Sigue siendo el lenguaje de más bajo nivel con legibilidad humana y se usa hoy en sistemas embebidos, firmware, drivers y exploits.[1][3][4][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/Assembly_language
```

***
## NODO 5
**NAME**
```
A-0 HOPPER 1952
```

**DATE**
```
1952
```

**PLACE**
```
USA - Pennsylvania - Philadelphia
```

**WHO**
```
Grace Hopper (UNIVAC / Remington Rand)
```

**BRIEF DESCRIPTION**
A-0 (1952) de Grace Hopper fue el primer compilador de la historia: un programa que traduce código simbólico a instrucciones de máquina. Esta invención conceptual —que un programa puede escribir otro programa— es la base de toda la cadena compilador/intérprete/transpilador que sustenta todos los lenguajes de alto nivel modernos. Hopper luego lideró el desarrollo de FLOW-MATIC, predecesor directo de COBOL.[1][2][3][4][5]

**LINK**
```
https://en.wikipedia.org/wiki/A-0_System
```

***
## NODO 6
**NAME**
```
FORTRAN 1957
```

**DATE**
```
1957
```

**PLACE**
```
USA - New York - New York
```

**WHO**
```
John W. Backus; IBM
```

**BRIEF DESCRIPTION**
FORTRAN (Formula Translation, IBM 1957) es el primer lenguaje de alto nivel de amplia adopción, diseñado para computación numérica y científica. Demostró que los compiladores podían producir código eficiente, provocando la expansión masiva de lenguajes de alto nivel. Fortran 2023 es su versión actual, con adopción vigente en HPC, meteorología, física computacional y CFD. La sonda Voyager 1 fue originalmente programada en FORTRAN.[1][2][7][3][8][4][5]

**LINK**
```
https://en.wikipedia.org/wiki/Fortran
https://fortran-lang.org/
```

***
## NODO 7
**NAME**
```
LISP 1958
```

**DATE**
```
1958
```

**PLACE**
```
USA - Massachusetts - Cambridge
```

**WHO**
```
John McCarthy (MIT)
```

**BRIEF DESCRIPTION**
LISP (List Processing, 1958) es el segundo lenguaje de alto nivel más antiguo aún en uso. Fue el primero en implementar recolección de basura automática, funciones de orden superior, recursión, homoiconicidad y macros. Es el lenguaje fundacional de la Inteligencia Artificial y el modelo computacional funcional. Influyó en Scheme, Clojure, Haskell, Python, Julia y practicamente todos los lenguajes modernos con funciones de primera clase.[1][2][7][3][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/Lisp_(programming_language)
```

***
## NODO 8
**NAME**
```
COBOL 1959
```

**DATE**
```
1959
```

**PLACE**
```
USA - Virginia - Arlington
```

**WHO**
```
CODASYL Committee; Grace Hopper (FLOW-MATIC); US DoD
```

**BRIEF DESCRIPTION**
COBOL (Common Business-Oriented Language, 1959) fue diseñado por el Comité CODASYL bajo influencia de Grace Hopper para estandarizar la programación en aplicaciones de negocio. Su sintaxis en inglés natural lo hace legible por no programadores. Se estima que en 2026 más de 220 mil millones de líneas de COBOL permanecen en producción en banca, seguros y gobierno. COBOL 2023 es su versión actual.[1][2][7][3][4][6][9][5]

**LINK**
```
https://en.wikipedia.org/wiki/COBOL
```

***
## NODO 9
**NAME**
```
ALGOL 60
```

**DATE**
```
1960
```

**PLACE**

**WHO**
```
ACM / GAMM Joint Committee (USA-Europa)
```

**BRIEF DESCRIPTION**
ALGOL 60 (Algorithmic Language 1960) es el lenguaje más influyente en la historia de las ciencias de la computación, a pesar de no tener gran adopción comercial. Introdujo bloques de código, alcance léxico, paso de parámetros por valor/nombre y la notación BNF para definir sintaxis. Es el ancestro directo de Pascal, C, Ada, Simula, Java, C#, Python y prácticamente toda la familia de lenguajes estructurados modernos.[1][10][7][3][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/ALGOL_60
```

***
## NODO 10
**NAME**
```
APL 1962
```

**DATE**
```
1962
```

**PLACE**
```
USA - New York - New York
```

**WHO**
```
Kenneth E. Iverson (IBM)
```

**BRIEF DESCRIPTION**
APL (A Programming Language, 1962) introdujo programación matricial/vectorial con operadores simbólicos compactos, permitiendo manipular arrays completos en una expresión. Influyó en MATLAB, NumPy, R, J, K y Q. Es el predecesor conceptual de la programación vectorizada masiva en ciencia de datos y computación financiera.[1][10][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/APL_(programming_language)
```

***
## NODO 11
**NAME**
```
BASIC 1964
```

**DATE**
```
1964
```

**PLACE**
```
USA - New Hampshire - Hanover
```

**WHO**
```
John G. Kemeny; Thomas E. Kurtz (Dartmouth College)
```

**BRIEF DESCRIPTION**
BASIC (Beginner's All-purpose Symbolic Instruction Code, 1964) fue diseñado para democratizar la programación entre estudiantes no científicos. Con la llegada de los microcomputadores (1975–1985), BASIC se convirtió en el primer lenguaje de toda una generación de programadores. Microsoft BASIC, Applesoft BASIC, QBASIC y Visual Basic son sus derivados directos más influyentes.[1][10][7][3][4][5]

**LINK**
```
https://en.wikipedia.org/wiki/BASIC
```

***
## NODO 12
**NAME**
```
SIMULA 67
```

**DATE**
```
1967
```

**PLACE**
```
Norway - Oslo
```

**WHO**
```
Ole-Johan Dahl; Kristen Nygaard (Norsk Regnesentral)
```

**BRIEF DESCRIPTION**
Simula 67 (1967) es el primer lenguaje de programación orientada a objetos (OOP), introduciendo clases, objetos, herencia y vinculación dinámica. Su influencia directa sobre Smalltalk, C++, Java, C# y prácticamente todos los lenguajes modernos de OOP es inconmensurable. También introdujo el paradigma de simulación de eventos discretos, base de la simulación computacional moderna.[1][10][7][3][11][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/Simula
```

***
## NODO 13
**NAME**
```
C LENGUAJE 1972
```

**DATE**
```
1972
```

**PLACE**
```
USA - New Jersey - Murray Hill
```

**WHO**
```
Dennis Ritchie (Bell Laboratories / AT&T)
```

**BRIEF DESCRIPTION**
C (1972) fue creado para re-implementar el sistema operativo UNIX. Es el lenguaje más influyente de la historia de la computación por su combinación única de eficiencia, portabilidad y poder de bajo nivel. Directamente precursor de C++, C#, Java, Go, Rust, Swift, Objective-C y docenas de lenguajes. C23 es su versión actual. El kernel de Linux, gran parte de macOS/iOS y la mayoría de firmware embebido están escritos en C.[1][10][7][3][8][4][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/C_(programming_language)
```

***
## NODO 14
**NAME**
```
PROLOG 1972
```

**DATE**
```
1972
```

**PLACE**
```
France - Occitanie - Marseille
```

**WHO**
```
Alain Colmerauer; Philippe Roussel (Université Aix-Marseille)
```

**BRIEF DESCRIPTION**
Prolog (Programming in Logic, 1972) estableció el paradigma de programación lógica declarativa basada en cláusulas de Horn. Es el lenguaje estándar para IA simbólica, procesamiento de lenguaje natural, sistemas expertos y deducción automática. Influyó en Mercury, Erlang y los motor de inferencia modernos.[1][7][5]

**LINK**
```
https://en.wikipedia.org/wiki/Prolog
```

***
## NODO 15
**NAME**
```
SQL 1972
```

**DATE**
```
1972
```

**PLACE**
```
USA - California - San Jose
```

**WHO**
```
Donald D. Chamberlin; Raymond F. Boyce (IBM Research)
```

**BRIEF DESCRIPTION**
SQL (Structured Query Language, 1972–1974; estándar ANSI 1986) es el lenguaje de consulta y manipulación de bases de datos relacionales más utilizado en la historia. Basado en el álgebra relacional de Codd (1970), es el lenguaje de facto de toda la industria de datos. En 2026 permanece como lenguaje central en data warehousing, analytics, BI y ciencia de datos.[1][7][5]

**LINK**
```
https://en.wikipedia.org/wiki/SQL
```

***
## NODO 16
**NAME**
```
ML TYPE SYSTEM
```

**DATE**
```
1973
```

**PLACE**
```
UK - Scotland - Edinburgh
```

**WHO**
```
Robin Milner (University of Edinburgh)
```

**BRIEF DESCRIPTION**
ML (Meta Language, 1973) introdujo el sistema de tipos estático con inferencia de tipos (algoritmo W de Hindley-Milner), pattern matching algebraico y funciones de orden superior con seguridad de tipos verificada en compilación. Es el ancestro directo de Standard ML, OCaml, F#, Haskell y todos los lenguajes funcionales con tipos algebraicos modernos, incluidos Rust y Elm.[1][10][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/ML_(programming_language)
```

***
## NODO 17
**NAME**
```
SMALLTALK 1976
```

**DATE**
```
1972
```

**PLACE**
```
USA - California - Palo Alto
```

**WHO**
```
Alan Kay; Adele Goldberg; Dan Ingalls (Xerox PARC)
```

**BRIEF DESCRIPTION**
Smalltalk (1972–1980) perfeccionó la programación orientada a objetos como un sistema completo: todo es un objeto, incluyendo clases, bloques e integers. Introdujo el entorno de desarrollo visual interactivo (IDE), la metáfora del escritorio y los bloques de código como objetos. Influyó en Objective-C, Java, Ruby, Python, Scala y la filosofía de diseño de software moderno.[1][10][7][11][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/Smalltalk
```

***
## NODO 18
**NAME**
```
SCHEME 1975
```

**DATE**
```
1975
```

**PLACE**
```
USA - Massachusetts - Cambridge
```

**WHO**
```
Gerald Jay Sussman; Guy L. Steele Jr. (MIT)
```

**BRIEF DESCRIPTION**
Scheme (1975) fue una revisión minimalista de LISP que introdujo el llamado de cola (tail-call optimization), cierres lexicales (closures) como ciudadanos de primer orden y continuaciones. Es el lenguaje de enseñanza de ciencias de la computación más influyente (SICP, MIT), base de Racket, y sus principios fundamentales están en JavaScript, Python, Ruby y Clojure.[1][10][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/Scheme_(programming_language)
```

***
## NODO 19
**NAME**
```
C++ 1983
```

**DATE**
```
1983
```

**PLACE**
```
USA - New Jersey - Murray Hill
```

**WHO**
```
Bjarne Stroustrup (Bell Laboratories)
```

**BRIEF DESCRIPTION**
C++ (1983) extendió C con clases (tomadas de Simula), sobrecarga de operadores, plantillas (templates) y RAII. Es el lenguaje de sistemas de alto rendimiento más usado del mundo en videojuegos, sistemas operativos, compiladores, motores físicos, HPC y software embebido. C++23 es su versión actual, con C++26 en desarrollo activo.[1][10][7][3][8][11][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/C%2B%2B
https://isocpp.org/
```

***
## NODO 20
**NAME**
```
ADA LENGUAJE 1980
```

**DATE**
```
1980
```

**PLACE**
```
France - Île-de-France - Paris
```

**WHO**
```
Jean Ichbiah; CII Honeywell Bull (contrato US DoD)
```

**BRIEF DESCRIPTION**
Ada (1980, estandarizado MIL-STD-1815, 1983) fue diseñado por mandato del Departamento de Defensa de EE.UU. para sistemas críticos de seguridad (aviación, defensa, ferroviario, médico). Introdujo tipos fuertemente tipados, manejo de excepciones, concurrencia mediante tareas (tasks) y programación genérica. Ada 2023 es su versión actual. Es el lenguaje de referencia para software certificado DO-178C y EN 50128.[1][10][7][3][4][6][5]

**LINK**
```
https://en.wikipedia.org/wiki/Ada_(programming_language)
https://www.adacore.com/
```

***
## NODO 21
**NAME**
```
MATLAB 1984
```

**DATE**
```
1984
```

**PLACE**
```
USA - New Mexico - Albuquerque
```

**WHO**
```
Cleve Moler (Univ. New Mexico); MathWorks (Jack Little, 1984)
```

**BRIEF DESCRIPTION**
MATLAB (Matrix Laboratory, ~1978 concepto; MathWorks 1984) es el lenguaje de computación numérica y visualización dominante en ingeniería, control, procesamiento de señales e investigación científica. Sus toolboxes de simulación (Simulink), control, estadística y aprendizaje automático lo hacen el estándar de ingeniería en NASA, Boeing y la mayoría de universidades técnicas del mundo. Su influencia directa incluye a Octave, Julia y SciPy.[1][7][8][5]

**LINK**
```
https://www.mathworks.com/products/matlab.html
https://en.wikipedia.org/wiki/MATLAB
```

***
## NODO 22
**NAME**
```
PERL 1987
```

**DATE**
```
1987
```

**PLACE**
```
USA - California - Los Angeles
```

**WHO**
```
Larry Wall (Unisys)
```

**BRIEF DESCRIPTION**
Perl (1987) fue el primer lenguaje de scripting de propósito general para automatización Unix, procesamiento de texto y administración de sistemas. Su potente manejo de expresiones regulares lo hizo estándar en bioinformática, administración de redes y scripting web en la era CGI. Precedió e influyó fuertemente en Python, PHP y Ruby.[1][7][3][8][4][5]

**LINK**
```
https://en.wikipedia.org/wiki/Perl
https://www.perl.org/
```

***
## NODO 23
**NAME**
```
ERLANG 1986
```

**DATE**
```
1986
```

**PLACE**
```
Sweden - Stockholm
```

**WHO**
```
Joe Armstrong; Robert Virding; Mike Williams (Ericsson)
```

**BRIEF DESCRIPTION**
Erlang (1986) fue diseñado para sistemas de telecomunicaciones con requisitos de alta disponibilidad (99.9999999% uptime). Introdujo el modelo de actores para concurrencia masiva, supervisiores de procesos y hot code swapping (actualización sin detener el sistema). Es el fundamento de Elixir, RabbitMQ y el sistema de mensajería de WhatsApp (2 mil millones de usuarios).[1][7][8][5]

**LINK**
```
https://en.wikipedia.org/wiki/Erlang_(programming_language)
https://www.erlang.org/
```

***
## NODO 24
**NAME**
```
HASKELL 1990
```

**DATE**
```
1990
```

**PLACE**

**WHO**
```
Simon Peyton Jones; Paul Hudak; Philip Wadler (IFIP WG 2.8)
```

**BRIEF DESCRIPTION**
Haskell (1990) es el lenguaje funcional puro de referencia académica e industrial, con evaluación perezosa (lazy evaluation), tipos algebraicos, typeclasses y monads. Ha influido directamente en Scala, F#, Rust, Elm, PureScript, TypeScript (tipos) y Swift. Es el laboratorio de ideas de lenguajes funcionales más influyente del siglo XXI.[1][10][7][3][11][5]

**LINK**
```
https://www.haskell.org/
https://en.wikipedia.org/wiki/Haskell
```

***
## NODO 25
**NAME**
```
PYTHON 1991
```

**DATE**
```
1991
```

**PLACE**
```
Netherlands - Amsterdam
```

**WHO**
```
Guido van Rossum (CWI)
```

**BRIEF DESCRIPTION**
Python (1991) fue diseñado como lenguaje de scripting de alta legibilidad, basado en indentación significativa. Su ascenso al dominio global (2020–2026) se debe a su ecosistema de ciencia de datos (NumPy, pandas, scikit-learn, TensorFlow, PyTorch) y a ser el lenguaje de facto para machine learning e IA. En 2024–2026 es el lenguaje #1 en todos los índices (TIOBE, PYPL, IEEE Spectrum).[1][10][7][3][4][6][5]

**LINK**
```
https://www.python.org/
https://en.wikipedia.org/wiki/Python_(programming_language)
```

***
## NODO 26
**NAME**
```
R LANG 1993
```

**DATE**
```
1993
```

**PLACE**
```
New Zealand - Auckland
```

**WHO**
```
Robert Gentleman; Ross Ihaka (University of Auckland)
```

**BRIEF DESCRIPTION**
R (1993), basado en S (Bell Labs, 1976), es el lenguaje estándar para estadística computacional, bioestadística, epidemiología y ciencia de datos. CRAN (Comprehensive R Archive Network) aloja más de 21,000 paquetes. R Markdown y Shiny lo extienden a documentación reproducible y aplicaciones web analíticas. Compite con Python en el espacio de análisis estadístico.[1][3][5]

**LINK**
```
https://www.r-project.org/
https://en.wikipedia.org/wiki/R_(programming_language)
```

***
## NODO 27
**NAME**
```
JAVA 1995
```

**DATE**
```
1995
```

**PLACE**
```
USA - California - Menlo Park
```

**WHO**
```
James Gosling; Mike Sheridan; Patrick Naughton (Sun Microsystems)
```

**BRIEF DESCRIPTION**
Java (1995) introdujo el modelo "Write Once, Run Anywhere" (WORA) mediante la Java Virtual Machine (JVM), junto con gestión automática de memoria, tipado estático fuerte y OOP pura. Dominó el desarrollo empresarial backend, Android (hasta 2017) y sistemas distribuidos. En 2026 es el lenguaje más usado en sistemas empresariales legacy y Android. OpenJDK y GraalVM son sus distribuciones actuales.[1][10][7][3][4][11][6][5]

**LINK**
```
https://www.java.com/
https://en.wikipedia.org/wiki/Java_(programming_language)
```

***
## NODO 28
**NAME**
```
JAVASCRIPT 1995
```

**DATE**
```
1995-12-04
```

**PLACE**
```
USA - California - Mountain View
```

**WHO**
```
Brendan Eich (Netscape Communications)
```

**BRIEF DESCRIPTION**
JavaScript (1995, originalmente LiveScript) fue creado en 10 días por Brendan Eich para añadir interactividad a Netscape Navigator. Estandarizado como ECMAScript en 1997, es el único lenguaje que se ejecuta nativamente en todos los navegadores web del mundo. Node.js (2009) lo llevó al backend. En 2026 es el lenguaje más usado globalmente en desarrollo web front-end y full-stack.[1][10][7][3][8][4][11][5]

**LINK**
```
https://en.wikipedia.org/wiki/JavaScript
https://tc39.es/ecma262/
```

***
## NODO 29
**NAME**
```
PHP 1995
```

**DATE**
```
1995
```

**PLACE**
```
Canada - British Columbia - Vancouver
```

**WHO**
```
Rasmus Lerdorf
```

**BRIEF DESCRIPTION**
PHP (Personal Home Page Tools, 1995) fue el primer lenguaje de scripting del lado del servidor de adopción masiva para web dinámico. En su apogeo (2000–2010) ejecutaba el 80%+ de los sitios web del mundo, incluyendo WordPress (40%+ del web en 2026), Wikipedia y Facebook (originalmente). PHP 8.x (2023–2025) incluye JIT compiler y sistema de tipos mejorado.[1][7][3][5]

**LINK**
```
https://www.php.net/
https://en.wikipedia.org/wiki/PHP
```

***
## NODO 30
**NAME**
```
RUBY 1995
```

**DATE**
```
1995
```

**PLACE**
```
Japan - Shimane
```

**WHO**
```
Yukihiro "Matz" Matsumoto
```

**BRIEF DESCRIPTION**
Ruby (1995) fue diseñado con enfoque en la felicidad del programador, combinando OOP puro de Smalltalk con flexibilidad de Perl. Ruby on Rails (2004, David Heinemeier Hansson) lo catapultó al desarrollo web ágil, estableciendo el patrón MVC como estándar de facto para frameworks web. Influyó en Elixir, Crystal y CoffeeScript.[1][7][3][8][4][5]

**LINK**
```
https://www.ruby-lang.org/
https://en.wikipedia.org/wiki/Ruby_(programming_language)
```

***
## NODO 31
**NAME**
```
CSS 1996
```

**DATE**
```
1996
```

**PLACE**

**WHO**
```
Håkon Wium Lie; Bert Bos (W3C)
```

**BRIEF DESCRIPTION**
CSS (Cascading Style Sheets, W3C 1996) separó la presentación visual del contenido estructural (HTML), permitiendo diseño responsive, temas y accesibilidad web. CSS3 introdujo animaciones, Grid, Flexbox y variables. Es el lenguaje de estilado visual universal del web, utilizado en combinación con HTML5 y JavaScript en el 100% de los sitios web del mundo.[1][5]

**LINK**
```
https://www.w3.org/Style/CSS/
https://en.wikipedia.org/wiki/CSS
```

***
## NODO 32
**NAME**
```
C# LENGUAJE 2000
```

**DATE**
```
2000
```

**PLACE**
```
USA - Washington - Redmond
```

**WHO**
```
Anders Hejlsberg; Microsoft Corporation (ECMA/ISO)
```

**BRIEF DESCRIPTION**
C# (2000) fue diseñado por Anders Hejlsberg para la plataforma .NET, combinando lo mejor de C++, Java y Delphi. Introdujo LINQ (Language Integrated Query), async/await como sintaxis nativa, y los más completos generics de su generación. Es el lenguaje principal de Unity (70%+ del mercado de videojuegos indie), desarrollo de Windows y Azure. C# 13 (2024) es su versión actual.[1][10][7][3][11][6][5]

**LINK**
```
https://learn.microsoft.com/en-us/dotnet/csharp/
https://en.wikipedia.org/wiki/C_Sharp_(programming_language)
```

***
## NODO 33
**NAME**
```
SCALA 2003
```

**DATE**
```
2003
```

**PLACE**
```
Switzerland - Vaud - Lausanne
```

**WHO**
```
Martin Odersky (EPFL)
```

**BRIEF DESCRIPTION**
Scala (2003) unificó OOP y programación funcional sobre la JVM, con tipos algebraicos, pattern matching exhaustivo e inferencia de tipos avanzada. Es el lenguaje de Apache Spark (big data) y Akka (sistemas reactivos). Influyó directamente en Kotlin, Dotty (Scala 3) y el diseño de tipos algebraicos en TypeScript.[1][7][8][11][5]

**LINK**
```
https://www.scala-lang.org/
https://en.wikipedia.org/wiki/Scala_(programming_language)
```

***
## NODO 34
**NAME**
```
F# LENGUAJE 2005
```

**DATE**
```
2005
```

**PLACE**
```
UK - England - Cambridge
```

**WHO**
```
Don Syme (Microsoft Research Cambridge)
```

**BRIEF DESCRIPTION**
F# (2005) es el lenguaje funcional de primera clase en .NET, derivado de OCaml. Introdujo computation expressions, active patterns y un sistema de unidades de medida verificado en compilación (unique en el mundo). Es el lenguaje de modelado financiero cuantitativo y análisis científico en el ecosistema Microsoft, con soporte completo en Azure y Visual Studio.[1][7][5]

**LINK**
```
https://fsharp.org/
https://en.wikipedia.org/wiki/F_Sharp_(programming_language)
```

***
## NODO 35
**NAME**
```
CLOJURE 2007
```

**DATE**
```
2007
```

**PLACE**
```
USA - New York - New York
```

**WHO**
```
Rich Hickey
```

**BRIEF DESCRIPTION**
Clojure (2007) es un LISP moderno para la JVM (y JavaScript/CLR vía ClojureScript/ClojureCLR), con énfasis en inmutabilidad, concurrencia mediante STM (Software Transactional Memory) y estructuras de datos persistentes. Su filosofía de "state management" influyó profundamente en Redux (React) y la arquitectura de aplicaciones funcionales modernas.[1][7][8][5]

**LINK**
```
https://clojure.org/
https://en.wikipedia.org/wiki/Clojure
```

***
## NODO 36
**NAME**
```
GO LANG 2009
```

**DATE**
```
2009
```

**PLACE**
```
USA - California - Mountain View
```

**WHO**
```
Robert Griesemer; Rob Pike; Ken Thompson (Google)
```

**BRIEF DESCRIPTION**
Go (2009) fue diseñado por Google para sistemas de infraestructura cloud a gran escala: compilación rápida, goroutines para concurrencia masiva, garbage collection de baja latencia y binarios estáticos. Docker, Kubernetes, Terraform y etcd están escritos en Go. Es el lenguaje de facto del ecosistema cloud-native (CNCF) en 2026.[1][7][3][8][11][5]

**LINK**
```
https://go.dev/
https://en.wikipedia.org/wiki/Go_(programming_language)
```

***
## NODO 37
**NAME**
```
RUST LANG 2010
```

**DATE**
```
2010
```

**PLACE**
```
USA - California - San Francisco
```

**WHO**
```
Graydon Hoare; Mozilla Foundation; Rust Foundation (2021)
```

**BRIEF DESCRIPTION**
Rust (2010) resuelve el problema de seguridad de memoria sin garbage collector mediante un sistema de ownership/borrowing verificado en compilación, eliminando data races y use-after-free. Seleccionado por el kernel Linux (2022), el kernel Windows (2023), Android y la Casa Blanca (ONCD, 2024) como lenguaje de sistemas seguro. En 2026 es el lenguaje de más rápido crecimiento en sistemas embebidos, WebAssembly y blockchain.[1][7][3][8][11][5]

**LINK**
```
https://www.rust-lang.org/
https://en.wikipedia.org/wiki/Rust_(programming_language)
```

***
## NODO 38
**NAME**
```
KOTLIN 2011
```

**DATE**
```
2011
```

**PLACE**
```
Russia - Saint Petersburg
```

**WHO**
```
Andrey Breslav; JetBrains
```

**BRIEF DESCRIPTION**
Kotlin (2011) es un lenguaje de tipado estático para JVM, Android, iOS (Kotlin Multiplatform) y web (Kotlin/JS), diseñado para ser 100% interoperable con Java y eliminar el boilerplate. Google lo declaró lenguaje oficial de Android en 2017. Kotlin Multiplatform Mobile (KMM) es en 2026 la alternativa principal a React Native y Flutter para desarrollo cross-platform.[1][7][8][11][5]

**LINK**
```
https://kotlinlang.org/
https://en.wikipedia.org/wiki/Kotlin_(programming_language)
```

***
## NODO 39
**NAME**
```
TYPESCRIPT 2012
```

**DATE**
```
2012
```

**PLACE**
```
USA - Washington - Redmond
```

**WHO**
```
Anders Hejlsberg; Microsoft Corporation
```

**BRIEF DESCRIPTION**
TypeScript (2012) añade un sistema de tipos estático opcional sobre JavaScript, compilando a JavaScript puro. En 2026 es el estándar de facto para desarrollo frontend y backend (Node.js) a escala: Angular, React, Vue y casi todos los frameworks web modernos lo requieren. Adoptado por Deno y Bun como lenguaje nativo.[1][7][3][8][11][5]

**LINK**
```
https://www.typescriptlang.org/
https://en.wikipedia.org/wiki/TypeScript
```

***
## NODO 40
**NAME**
```
ELIXIR 2012
```

**DATE**
```
2012
```

**PLACE**
```
Brazil - São Paulo
```

**WHO**
```
José Valim (Plataformatec)
```

**BRIEF DESCRIPTION**
Elixir (2012) es un lenguaje funcional dinámico sobre la BEAM VM (Erlang), combinando la sintaxis de Ruby con la tolerancia a fallos de Erlang. Phoenix LiveView redefinió el desarrollo web con estado en el servidor. Es adoptado por Discord, Pinterest y Bleacher Report para sistemas de alta concurrencia y disponibilidad.[1][7][8][5]

**LINK**
```
https://elixir-lang.org/
https://en.wikipedia.org/wiki/Elixir_(programming_language)
```

***
## NODO 41
**NAME**
```
JULIA LANG 2012
```

**DATE**
```
2012
```

**PLACE**
```
USA - Massachusetts - Cambridge
```

**WHO**
```
Jeff Bezanson; Stefan Karpinski; Viral Shah; Alan Edelman (MIT)
```

**BRIEF DESCRIPTION**
Julia (2012) fue diseñado para resolver el "two-language problem" en computación científica: combina la velocidad de C/Fortran con la productividad de Python/MATLAB mediante compilación JIT con LLVM y despacho múltiple. Es el lenguaje de computación de alto rendimiento para modelado climático, economía cuantitativa, bioinformática y simulaciones físicas en 2026.[1][7][8][5]

**LINK**
```
https://julialang.org/
https://en.wikipedia.org/wiki/Julia_(programming_language)
```

***
## NODO 42
**NAME**
```
SWIFT APPLE 2014
```

**DATE**
```
2014
```

**PLACE**
```
USA - California - Cupertino
```

**WHO**
```
Chris Lattner; Apple Inc.
```

**BRIEF DESCRIPTION**
Swift (2014) reemplazó a Objective-C como lenguaje principal para desarrollo en iOS, macOS, watchOS y tvOS. Combina seguridad de tipos, optionals, closures y protocolos con rendimiento cercano a C. Swift 6.0 (2024) introduce concurrencia segura completa. Es el lenguaje de todas las apps del App Store de Apple (1.8 millones+ de apps).[1][7][3][8][11][5]

**LINK**
```
https://www.swift.org/
https://en.wikipedia.org/wiki/Swift_(programming_language)
```

***
## NODO 43
**NAME**
```
SOLIDITY 2014
```

**DATE**
```
2014
```

**PLACE**

**WHO**
```
Gavin Wood; Christian Reitwiessner; Ethereum Foundation
```

**BRIEF DESCRIPTION**
Solidity (2014) es el lenguaje de programación de contratos inteligentes en la blockchain de Ethereum. Su paradigma de ejecución determinista en la EVM (Ethereum Virtual Machine) define un nuevo modelo computacional de contratos autoejecutables inmutables. Es el lenguaje fundacional del ecosistema DeFi (Finanzas Descentralizadas) y NFT, con más de $50B en contratos desplegados en 2026.[1][7][8][5]

**LINK**
```
https://soliditylang.org/
https://en.wikipedia.org/wiki/Solidity
```

***
## NODO 44
**NAME**
```
ZIG LANG 2016
```

**DATE**
```
2016
```

**PLACE**
```
USA - New York - New York
```

**WHO**
```
Andrew Kelley
```

**BRIEF DESCRIPTION**
Zig (2016) es un lenguaje de sistemas de bajo nivel sin garbage collector y sin runtime oculto, diseñado como sucesor espiritual de C con mayor seguridad y facilidad de interoperabilidad con C/C++. Su compilador puede compilar proyectos C/C++ existentes. En 2026 tiene creciente adopción en firmware, compiladores y como toolchain alternativo a Clang.[1][7][5]

**LINK**
```
https://ziglang.org/
https://en.wikipedia.org/wiki/Zig_(programming_language)
```

***
## NODO 45
**NAME**
```
MOJO 2023
```

**DATE**
```
2023
```

**PLACE**
```
USA - California - San Francisco
```

**WHO**
```
Chris Lattner; Modular Inc.
```

**BRIEF DESCRIPTION**
Mojo (2023) es un lenguaje creado por Chris Lattner (creador de Swift y LLVM) para unificar Python con el rendimiento de C para IA/ML, con 35,000x–68,000x speedup sobre Python puro en benchmarks de operaciones numéricas. Usa MLIR como infraestructura de compilación. Representa el estado del arte en lenguajes para computación de IA de alto rendimiento en 2024–2026.[1][7][8][12][5]

**LINK**
```
https://www.modular.com/mojo
https://en.wikipedia.org/wiki/Mojo_(programming_language)
```

***
## NODO 46
**NAME**
```
CANGJIE HUAWEI
```

**DATE**
```
2024
```

**PLACE**
```
China - Guangdong - Shenzhen
```

**WHO**
```
Xinyu Feng; Huawei Technologies
```

**BRIEF DESCRIPTION**
Cangjie (仓颉, 2024) es el lenguaje de programación de propósito general desarrollado por Huawei como parte de la plataforma HarmonyOS NEXT, diseñado para reemplazar gradualmente Java, TypeScript y JavaScript en el ecosistema Huawei. Introduce concurrencia segura similar a Rust, tipado algebraico y soporte nativo para IA embebida, siendo el primer lenguaje de programación diseñado por una empresa china para su propio ecosistema OS a escala global.[1][5]

**LINK**
```
https://developer.huawei.com/consumer/en/cangjie/
```