Historia de los lenguajes de programación

La historia de los lenguajes de programación abarca desde la documentación de las primeras computadoras mecánicas hasta las herramientas modernas para el desarrollo de software. Los primeros lenguajes de programación eran altamente especializados y se basaban en la notación matemática y una sintaxis igualmente oscura. A lo largo del siglo XX, la investigación en la teoría de los compiladores condujo a la creación de lenguajes de programación de alto nivel, que utilizan una sintaxis más accesible para comunicar instrucciones.

El primer lenguaje de programación de alto nivel fue Plankalkül, creado por Konrad Zuse entre 1942 y 1945. El primer lenguaje de alto nivel en tener un compilador asociado fue creado por Corrado Böhm en 1951, para su tesis doctoral. El primer lenguaje comercialmente disponible fue FORTRAN (FORMula TRANslation), desarrollado en 1956 (el primer manual apareció en 1956, pero desarrollado por primera vez en 1954) por un equipo dirigido por John Backus en IBM.

Historia temprana

Durante 1842–1849, Ada Lovelace tradujo las memorias del matemático italiano Luigi Menabrea sobre la máquina propuesta más nueva de Charles Babbage: el motor analítico; Complementó las memorias con notas que especificaban en detalle un método para calcular los números de Bernoulli con el motor, reconocido por la mayoría de los historiadores como el primer programa informático publicado en el mundo.

Los primeros códigos informáticos estaban especializados para sus aplicaciones: por ejemplo, Alonzo Church podía expresar el cálculo lambda de forma formulaica y la máquina de Turing era una abstracción del funcionamiento de una máquina marcadora de cinta.

Jacquard Looms y la máquina diferencial de Charles Babbage tenían lenguajes simples para describir las acciones que estas máquinas deberían realizar, por lo que fueron los creadores del primer lenguaje de programación.

Primeros lenguajes de programación

En la década de 1940, se crearon las primeras computadoras eléctricas reconociblemente modernas. La velocidad y la capacidad de memoria limitadas obligaron a los programadores a escribir programas en lenguaje ensamblador ajustados a mano. Finalmente se dio cuenta de que la programación en lenguaje ensamblador requería una gran cantidad de esfuerzo intelectual.

Una de las primeras propuestas para un lenguaje de programación de alto nivel fue Plankalkül, desarrollado por Konrad Zuse para su computadora Z1 entre 1942 y 1945 pero no implementado en ese momento.

Los primeros lenguajes de programación en funcionamiento diseñados para comunicar instrucciones a una computadora se escribieron a principios de la década de 1950. El código corto de John Mauchly, propuesto en 1949, fue uno de los primeros lenguajes de alto nivel desarrollados para una computadora electrónica. A diferencia del código de máquina, las declaraciones de código corto representaban expresiones matemáticas en forma comprensible. Sin embargo, el programa tenía que traducirse a código de máquina cada vez que se ejecutaba, lo que hacía que el proceso fuera mucho más lento que ejecutar el código de máquina equivalente.

A principios de la década de 1950, Alick Glennie desarrolló Autocode, posiblemente el primer lenguaje de programación compilado, en la Universidad de Manchester. En 1954, RA Brooker desarrolló una segunda iteración del lenguaje, conocida como "Mark 1 Autocode", para Mark 1. Brooker también desarrolló un código automático para Ferranti Mercury en la década de 1950 junto con la Universidad de Manchester. La versión para EDSAC 2 fue ideada por Douglas Hartree del Laboratorio Matemático de la Universidad de Cambridge en 1961. Conocido como EDSAC 2 Autocode, fue un desarrollo directo de Mercury Autocode adaptado a las circunstancias locales y se destacó por su optimización de código objeto y lenguaje fuente. diagnósticos avanzados para la época. Un hilo de desarrollo contemporáneo pero separado,

En 1954, FORTRAN fue inventado en IBM por un equipo dirigido por John Backus; fue el primer lenguaje de programación de propósito general de alto nivel ampliamente utilizado en tener una implementación funcional, en lugar de solo un diseño en papel. Cuando FORTRAN se introdujo por primera vez, se vio con escepticismo debido a errores, retrasos en el desarrollo y la eficiencia comparativa de los programas "codificados a mano" escritos en ensamblador. Sin embargo, en un mercado de hardware que evolucionaba rápidamente; el idioma finalmente se hizo conocido por su eficiencia. Todavía es un lenguaje popular para la computación de alto rendimiento y se usa para programas que comparan y clasifican las supercomputadoras más rápidas del mundo.

Otro lenguaje de programación temprano fue ideado por Grace Hopper en los EE. UU., llamado FLOW-MATIC. Fue desarrollado para UNIVAC I en Remington Rand durante el período de 1955 a 1959. Hopper descubrió que los clientes de procesamiento de datos comerciales no se sentían cómodos con la notación matemática y, a principios de 1955, ella y su equipo escribieron una especificación para un lenguaje de programación en inglés e implementaron un prototipo El compilador FLOW-MATIC estuvo disponible públicamente a principios de 1958 y se completó sustancialmente en 1959. Flow-Matic fue una gran influencia en el diseño de COBOL, ya que solo él y su descendiente directo AIMACO estaban en uso real en ese momento.

Otros lenguajes que todavía se usan en la actualidad incluyen LISP (1958), inventado por John McCarthy y COBOL (1959), creado por el Comité de Corto Alcance. Otro hito a fines de la década de 1950 fue la publicación, por parte de un comité de científicos informáticos estadounidenses y europeos, de "un nuevo lenguaje para algoritmos"; el Informe ALGOL 60 (el " Lenguaje rítmico ALGO "). Este informe consolidó muchas ideas que circulaban en ese momento y presentó tres innovaciones lingüísticas clave:

• estructura de bloques anidados: las secuencias de código y las declaraciones asociadas podrían agruparse en bloques sin tener que convertirlos en procedimientos separados con nombres explícitos;
• alcance léxico: un bloque podría tener sus propias variables, procedimientos y funciones privadas, invisibles para el código fuera de ese bloque, es decir, ocultación de información.

Otra innovación, relacionada con esto, fue en cómo se describió el lenguaje:

• se utilizó una notación matemáticamente exacta, la forma Backus-Naur (BNF), para describir la sintaxis del lenguaje. Casi todos los lenguajes de programación posteriores han utilizado una variante de BNF para describir la parte libre de contexto de su sintaxis.

Algol 60 fue particularmente influyente en el diseño de lenguajes posteriores, algunos de los cuales pronto se hicieron más populares. Los grandes sistemas de Burroughs fueron diseñados para ser programados en un subconjunto extendido de Algol.

Las ideas clave de Algol continuaron, produciendo ALGOL 68:

• la sintaxis y la semántica se hicieron aún más ortogonales, con rutinas anónimas, un sistema de tipeo recursivo con funciones de orden superior, etc.;
• no solo la parte libre de contexto, sino también la sintaxis y la semántica del lenguaje completo se definieron formalmente, en términos de la gramática de Van Wijngaarden, un formalismo diseñado específicamente para este propósito.

Las muchas funciones de lenguaje poco utilizadas de Algol 68 (por ejemplo, bloques concurrentes y paralelos) y su complejo sistema de accesos directos sintácticos y coerciones automáticas de tipos lo hicieron impopular entre los implementadores y le ganaron la reputación de ser difícil. Niklaus Wirth abandonó el comité de diseño para crear el lenguaje Pascal más simple.

Algunos lenguajes notables que se desarrollaron en este período incluyen:

• 1951 - Lenguaje ensamblador regional
• 1952 – Autocodificación
• 1954 - IPL (precursor de LISP)
• 1955 – FLOW-MATIC (condujo a COBOL)
• 1957 – FORTRAN (primer compilador)
• 1957 - COMTRAN (precursor de COBOL)
• 1958 – LISP
• 1958 – ALGOL 58
• 1959 – HECHO (precursor de COBOL)
• 1959-COBOL
• 1959 – juego de rol
• 1962 – APL
• 1962 – Simula
• 1962 – SNOBOL
• 1963 - CPL (precursor de C)
• 1964 - bar clandestino
• 1964 – BÁSICO
• 1964 – PL/I
• 1966 – Joss
• 1966 – PAPERAS
• 1967 - BCPL (precursor de C)

Estableciendo paradigmas fundamentales

El período comprendido entre finales de la década de 1960 y finales de la década de 1970 trajo un gran florecimiento de los lenguajes de programación. La mayoría de los principales paradigmas lingüísticos actualmente en uso se inventaron en este período:

• Speakeasy, desarrollado en 1964 en el Laboratorio Nacional de Argonne (ANL) por Stanley Cohen, es un paquete numérico OOPS (sistema de programación orientado a objetos, muy parecido a los posteriores MATLAB, IDL y Mathematica). Speakeasy tiene una sintaxis básica clara de Fortran. Primero abordó el cálculo físico eficiente internamente en ANL, se modificó para uso de investigación (como "Modeleasy") para la Junta de la Reserva Federal a principios de la década de 1970 y luego estuvo disponible comercialmente; Speakeasy y Modeleasy todavía están en uso actualmente.
• Simula, inventado a fines de la década de 1960 por Nygaard y Dahl como un superconjunto de Algol 60, fue el primer lenguaje diseñado para soportar la programación orientada a objetos.
• CUARTO, el lenguaje de programación concatenativo más antiguo fue diseñado por Charles Moore en 1969 como un sistema de desarrollo personal mientras trabajaba en el Observatorio Nacional de Radioastronomía (NRAO).
• C, uno de los primeros lenguajes de programación de sistemas, fue desarrollado por Dennis Ritchie y Ken Thompson en Bell Labs entre 1969 y 1973.
• Smalltalk (mediados de la década de 1970) proporcionó un diseño completo desde cero de un lenguaje orientado a objetos.
• Prolog, diseñado en 1972 por Colmerauer, Roussel y Kowalski, fue el primer lenguaje de programación lógica.
• ML construyó un sistema de tipos polimórficos (inventado por Robin Milner en 1973) sobre Lisp, siendo pionero en lenguajes de programación funcionales tipificados estáticamente.

Cada uno de estos idiomas generó una familia completa de descendientes, y la mayoría de los idiomas modernos cuentan con al menos uno de ellos en su ascendencia.

Las décadas de 1960 y 1970 también vieron un debate considerable sobre los méritos de la "programación estructurada", que esencialmente significaba programar sin el uso de "goto". Una fracción significativa de programadores creía que, incluso en lenguajes que proporcionan "goto", es un mal estilo de programación usarlo, excepto en raras circunstancias. Este debate estaba estrechamente relacionado con el diseño del lenguaje: algunos lenguajes no incluían un "goto" en absoluto, lo que forzaba la programación estructurada en el programador.

Para proporcionar tiempos de compilación aún más rápidos, algunos lenguajes se estructuraron para "compiladores de un solo paso" que esperan que las rutinas subordinadas se definan primero, como con Pascal, donde la rutina principal, o la función del controlador, es la sección final de la lista del programa.

Algunos lenguajes notables que se desarrollaron en este período incluyen:

• 1967 - BCPL (precursor de B)
• 1968 – Logotipo
• 1969 - B (precursor de C)
• 1970 – Pascual
• 1970 - Adelante
• 1972-C
• 1972 - Charla pequeña
• 1972 - Prólogo
• 1973 – ML
• 1975 – Esquema
• 1978 - SQL (un lenguaje de consulta, luego ampliado)

Década de 1980: consolidación, módulos, rendimiento

Los años 80 fueron años de relativa consolidación en las lenguas imperativas. En lugar de inventar nuevos paradigmas, todos estos movimientos elaboraron sobre las ideas inventadas en la década anterior. C++ combina programación orientada a objetos y de sistemas. El gobierno de los Estados Unidos estandarizó Ada, un lenguaje de programación de sistemas destinado a los contratistas de defensa. En Japón y en otros lugares, se gastaron grandes sumas de dinero investigando los llamados lenguajes de programación de quinta generación que incorporaron construcciones de programación lógica. La comunidad de lenguajes funcionales se movió para estandarizar ML y Lisp. La investigación en Miranda, un lenguaje funcional con evaluación perezosa, comenzó a afianzarse en esta década.

Una nueva tendencia importante en el diseño de lenguajes fue un mayor enfoque en la programación de sistemas a gran escala mediante el uso de módulos, o unidades organizativas de código a gran escala. Modula, Ada y ML desarrollaron notables sistemas de módulos en la década de 1980. Los sistemas de módulos a menudo se unían a construcciones de programación genéricas, siendo los genéricos, en esencia, módulos parametrizados (ver también polimorfismo en la programación orientada a objetos).

Aunque no aparecieron nuevos paradigmas importantes para los lenguajes de programación imperativos, muchos investigadores ampliaron las ideas de lenguajes anteriores y los adaptaron a nuevos contextos. Por ejemplo, los lenguajes de los sistemas Argus y Emerald adaptaron la programación orientada a objetos a los sistemas distribuidos.

La década de 1980 también trajo avances en la implementación del lenguaje de programación. El movimiento RISC en la arquitectura de computadoras postuló que el hardware debería diseñarse para compiladores en lugar de programadores de ensamblaje humanos. Con la ayuda de mejoras en la velocidad del procesador que permitieron técnicas de compilación cada vez más agresivas, el movimiento RISC despertó un mayor interés en la tecnología de compilación para lenguajes de alto nivel.

La tecnología del lenguaje continuó en esta línea hasta bien entrada la década de 1990.

Algunos lenguajes notables que se desarrollaron en este período incluyen:

• 1980 - C++ (como C con clases, renombrado en 1983)
• 1983 - Adá
• 1984 - ceceo común
• 1984 – MATLAB
• 1984: dBase III, dBase III Plus (Clipper y FoxPro como FoxBASE)
• 1985 – Eiffel
• 1986 – Objetivo-C
• 1986 - LabVIEW (Lenguaje de programación visual)
• 1986 – Erlang
• 1987 – Perla
• 1988 – TCL
• 1988 – Wolfram Language (como parte de Mathematica, solo obtuvo un nombre separado en junio de 2013)
• 1989 - Florida (Backus)

1990: la era de Internet

El rápido crecimiento de Internet a mediados de la década de 1990 fue el próximo gran evento histórico en los lenguajes de programación. Al abrir una plataforma radicalmente nueva para los sistemas informáticos, Internet creó una oportunidad para que se adoptaran nuevos lenguajes. En particular, el lenguaje de programación JavaScript ganó popularidad debido a su temprana integración con el navegador web Netscape Navigator. Varios otros lenguajes de secuencias de comandos lograron un uso generalizado en el desarrollo de aplicaciones personalizadas para servidores web como PHP. La década de 1990 no vio ninguna novedad fundamental en los lenguajes imperativos, sino mucha recombinación y maduración de viejas ideas. Esta era comenzó la difusión de los lenguajes funcionales. Una gran filosofía impulsora fue la productividad del programador. Surgieron muchos lenguajes de "desarrollo rápido de aplicaciones" (RAD), que generalmente venían con un IDE, recolección de basura, y eran descendientes de lenguas más antiguas. Todos estos lenguajes estaban orientados a objetos. Estos incluían Object Pascal, Visual Basic y Java. Java en particular recibió mucha atención.

Más radicales e innovadores que los lenguajes RAD fueron los nuevos lenguajes de scripting. Estos no descendían directamente de otros idiomas y presentaban nuevas sintaxis y una incorporación más liberal de funciones. Muchos consideran que estos lenguajes de secuencias de comandos son más productivos incluso que los lenguajes RAD, pero a menudo debido a opciones que hacen que los programas pequeños sean más simples pero que los programas grandes sean más difíciles de escribir y mantener. Sin embargo, los lenguajes de programación llegaron a ser los más prominentes utilizados en conexión con la Web.

Algunos lenguajes notables que se desarrollaron en este período incluyen:

• 1990 – Haskell
• 1990 - Pitón
• 1991 – Visual básico
• 1993 – Lúa
• 1993 – R
• 1994 - CLOS (parte de ANSI Common Lisp)
• 1995 – Rubí
• 1995 – Adá 95
• 1995 – Java
• 1995 – Delphi (Objeto Pascal)
• 1995 – JavaScript
• 1995 – PHP
• 1997 – Rebol

Tendencias actuales

La evolución del lenguaje de programación continúa, tanto en la industria como en la investigación. Algunas de las tendencias recientes han incluido:

• Aumentar el soporte para la programación funcional en los lenguajes principales utilizados comercialmente, incluida la programación funcional pura para hacer que el código sea más fácil de razonar y más fácil de paralelizar (tanto a nivel micro como macro).
• Construcciones para soportar la programación concurrente y distribuida.
• Mecanismos para agregar seguridad y verificación de confiabilidad al lenguaje: verificación estática extendida, tipeo dependiente, control de flujo de información, seguridad de subprocesos estáticos.
• Mecanismos alternativos de composición y modularidad: mixins, traits, typeclasses, delegados, aspectos.
• Desarrollo de software orientado a componentes.
• Metaprogramación, reflexión o acceso al árbol de sintaxis abstracta
  • AOP o Programación Orientada a Aspectos que permite a los desarrolladores insertar código en otro módulo o clase en "puntos de unión"
  • Lenguajes específicos de dominio y generación de código
    • XML para interfaz gráfica (XUL, XAML)
• Mayor interés por la distribución y la movilidad.
• Integración con bases de datos, incluidas XML y bases de datos relacionales.
• El código abierto como filosofía de desarrollo para lenguajes, incluida la colección de compiladores GNU y lenguajes como PHP, Python, Ruby y Scala.
• Más interés en lenguajes de programación visual como Scratch, LabVIEW y PWCT
• Lenguajes masivamente paralelos para unidades de procesamiento de gráficos de GPU y arreglos de supercomputadoras, incluido OpenCL
• Primeras investigaciones sobre lenguajes de programación de computación cuántica (ver lista)
• Primeras investigaciones sobre la aplicación de técnicas de inteligencia artificial para generar código como el uso de GPT-3

Algunos lenguajes notables desarrollados durante este período incluyen:

• 2000 – ActionScript
• 2001 – Do#
• 2001 – D
• 2002 – Rasguño
• 2003 – maravilloso
• 2003 – Escala
• 2005 – Fa#
• 2005 – SantoC
• 2006 – PowerShell
• 2007 – Clausura
• 2008 – Nim
• 2009 – Ir
• 2010 – óxido
• 2011 – Dardo
• 2011 – Kotlin
• 2011 – Elixir
• 2012 – Julio
• 2012 – Mecanografiado
• 2014 – Rápido

Otros nuevos lenguajes de programación incluyen Red, Crystal, Elm, Hack, Haxe, Zig y Reason.

Figuras claves

Algunas personas clave que ayudaron a desarrollar lenguajes de programación:

• Alan Cooper, desarrollador de Visual Basic.
• Alan Kay, trabajo pionero en programación orientada a objetos y creador de Smalltalk.
• Anders Hejlsberg, desarrollador de Turbo Pascal, Delphi, C# y TypeScript.
• Arthur Whitney, desarrollador de A+, k y q.
• Bertrand Meyer, inventor de Eiffel.
• Bjarne Stroustrup, desarrollador de C++.
• Brad Cox, cocreador de Objective-C.
• Brendan Eich, desarrollador de JavaScript.
• Brian Kernighan, coautor del primer libro sobre el lenguaje de programación C con Dennis Ritchie, coautor de los lenguajes de programación AWK y AMPL.
• Chuck Moore, inventor de Forth, el primer lenguaje de programación concatenativo y un nombre destacado en el diseño de microprocesadores de máquinas de pila.
• Chris Lattner, creador de Swift y LLVM.
• Cleve Moler, creador de MATLAB.
• Dennis Ritchie, inventor del sistema operativo C. Unix, sistema operativo Plan 9.
• Douglas McIlroy, influenció y diseñó lenguajes como SNOBOL, TRAC, PL/I, ALTRAN, TMG y C++.
• Grace Hopper, la primera en utilizar el término compilador y desarrollador de FLOW-MATIC, influyó en el desarrollo de COBOL. Popularizó los lenguajes de programación independientes de la máquina y el término "depuración".
• Guido van Rossum, creador de Python.
• James Gosling, desarrollador principal de Java y su precursor, Oak.
• Jean Ichbiah, diseñador jefe de Ada, Ada 83.
• Jean-Yves Girard, co-inventor del cálculo lambda polimórfico (Sistema F).
• Jeff Bezanson, diseñador principal y uno de los principales desarrolladores de Julia.
• Jeffrey Snover, inventor de PowerShell.
• Joe Armstrong, creador de Erlang.
• John Backus, inventor de Fortran y cooperó en el diseño de ALGOL 58 y ALGOL 60.
• John C. Reynolds, co-inventor del cálculo lambda polimórfico (Sistema F).
• John McCarthy, inventor de LISP.
• John von Neumann, creador del concepto de sistema operativo.
• Graydon Hoare, inventor de Rust.
• Ken Thompson, inventor de B, Go, Inferno (sistema operativo) y coautor del sistema operativo Unix.
• Kenneth E. Iverson, desarrollador de APL y co-desarrollador de J junto con Roger Hui.
• Konrad Zuse, diseñó el primer lenguaje de programación de alto nivel, Plankalkül (que influyó en ALGOL 58).
• Kristen Nygaard, pionera en programación orientada a objetos, co-inventora de Simula.
• Larry Wall, creador del lenguaje de programación Perl (ver Perl y Raku).
• Martin Odersky, creador de Scala y anteriormente colaborador del diseño de Java.
• Martin Richards desarrolló el lenguaje de programación BCPL, precursor de los lenguajes B y C.
• Nathaniel Rochester, inventor del primer ensamblador (IBM 701).
• Niklaus Wirth, inventor de Pascal, Modula y Oberon.
• Ole-Johan Dahl, pionero en la programación orientada a objetos, co-inventor de Simula.
• Rasmus Lerdorf, creador de PHP.
• Rich Hickey, creador de Clojure.
• Jean Paoli, cocreador de XML
• Robert Gentleman, cocreador de R.
• Robert Griesemer, cocreador de Go.
• Robin Milner, inventor de ML, y comparte el crédito por la inferencia de tipo polimórfico de Hindley-Milner.
• Rob Pike, cocreador de Go, Inferno (sistema operativo) y Plan 9 (sistema operativo), coautor del sistema operativo.
• Ross Ihaka, cocreador de R.
• Ryan Dahl, creador de Node.js.
• Stanley Cohen, inventor de Speakeasy, que fue creado con un OOPS, sistema de programación orientado a objetos, la primera instancia, en 1964.
• Stephen Wolfram, creador de Mathematica.
• Terry A. Davis, creador de HolyC.
• Walter Bright, creador de D.
• Yukihiro Matsumoto, creador de Ruby.