Lisp para niños

Datos para niños Lisp
John McCarthy y Steve Russell
Información general
Paradigma	Multiparadigma: funcional, por procedimientos, reflexión, Metaprogramación
Apareció en	1 de abril de 1960
Diseñado por	John McCarthy
Sistema de tipos	varios
Implementaciones	múltiples
Dialectos	Common Lisp, Scheme, Emacs Lisp, Clojure, AutoLISP, Hy, Arc, Franz Lisp, Maclisp, Racket
Influido por	Information Processing Language
Ha influido a	Perl, Python, Javascript, Lua, Scala, Ruby, R, Elixir, Haskell, Forth, Julia, Smalltalk, CLOS, Dylan, Wolfram

Lisp (que antes se escribía LISP) es una familia de lenguajes de programación para computadoras. Es muy antiguo y tiene una forma especial de escribir el código, basada en el uso de listas y paréntesis.

Fue creado en 1959 por John McCarthy y su equipo en el Instituto Tecnológico de Massachusetts (MIT). Lisp es el segundo lenguaje de programación de alto nivel más antiguo que existe. Apareció un año después de FORTRAN y uno antes que COBOL.

Al igual que otros lenguajes antiguos, Lisp ha cambiado mucho. Han surgido muchos "dialectos" (versiones diferentes) a lo largo de su historia. Hoy en día, los dialectos más usados son Scheme (creado en 1975), Common Lisp (1984), Emacs Lisp (1985) y Clojure (2007).

Lisp se creó inicialmente como una forma práctica de escribir programas de computadora usando ideas matemáticas. Rápidamente se convirtió en el lenguaje favorito para la investigación en inteligencia artificial (IA). Lisp fue pionero en muchas ideas importantes en la ciencias de la computación, como las estructuras de datos tipo árbol, la gestión automática de la memoria, los tipos de datos que pueden cambiar y los compiladores que pueden crearse a sí mismos.

El nombre LISP significa «LISt Processor», que en español es "procesador de listas". Las listas son muy importantes en Lisp. El código de Lisp se escribe usando listas. Esto permite que los programas de Lisp puedan manipular su propio código como si fueran datos normales. Esto es muy útil para crear herramientas que ayudan a los programadores a escribir código más fácilmente.

La forma en que el código y los datos se mezclan le da a Lisp su sintaxis única. Todo el código se escribe como "expresiones S", que son listas entre paréntesis. Cuando llamas a una función, escribes el nombre de la función primero y luego sus argumentos, todo dentro de paréntesis. Por ejemplo, si una función llamada "f" toma tres datos (x, y, z), se escribiría así: `(f x y z)`.

Historia de Lisp: Un Lenguaje Pionero

Lisp fue inventado por John McCarthy en 1958 en el MIT. McCarthy publicó su diseño el 1 de abril de 1960. En su artículo, mostró cómo con unos pocos comandos simples y una forma de escribir funciones, se podía crear un lenguaje completo para procesar información.

Antes de Lisp, existió el Information Processing Language (IPL) en 1955 o 1956. IPL ya tenía ideas como el procesamiento de listas y la recursión (cuando una función se llama a sí misma), que luego se usaron en Lisp.

La forma original de McCarthy para escribir Lisp usaba "expresiones M" con corchetes. Estas se convertían a las "expresiones S" que usan paréntesis. Sin embargo, los programadores prefirieron usar directamente las expresiones S, y las expresiones M se dejaron de lado.

¿Quién implementó Lisp por primera vez?

Lisp fue implementado por primera vez por Steve Russell en una computadora IBM 704. Russell leyó el artículo de McCarthy y se dio cuenta de que la función principal de Lisp, llamada eval, podía ser creada usando el lenguaje de la máquina. Así nació un programa que podía ejecutar código Lisp.

Dos comandos del lenguaje de la computadora IBM 704 se convirtieron en las operaciones básicas para dividir listas: car y cdr. Los dialectos de Lisp todavía usan "car" para obtener el primer elemento de una lista y "cdr" para obtener el resto de la lista.

El primer programa completo que convertía código Lisp a un formato que la computadora entendía (un compilador), fue escrito en Lisp en 1962 por Tim Hart y Mike Levin en el MIT. Este compilador permitió mezclar código Lisp que se ejecutaba directamente con código Lisp ya convertido.

Variantes y Evolución de Lisp

A lo largo de sus más de cincuenta años, Lisp ha tenido muchas versiones diferentes, llamadas dialectos. Además, cada dialecto puede tener varias implementaciones (formas de hacerlo funcionar). Por ejemplo, hay más de diez formas de usar Common Lisp.

Las diferencias entre los dialectos pueden ser grandes. Por ejemplo, Common Lisp y Scheme usan palabras diferentes para crear funciones. Sin embargo, dentro de un mismo dialecto que está estandarizado, las diferentes implementaciones suelen ser compatibles.

Lisp y la Inteligencia Artificial

Desde el principio, Lisp estuvo muy ligado a la investigación en inteligencia artificial. Fue usado para crear sistemas importantes de IA. En los años 70, cuando la investigación en IA empezó a tener aplicaciones comerciales, el rendimiento de los sistemas Lisp se convirtió en un problema.

Lisp era difícil de implementar con las computadoras y las herramientas de la época. Las rutinas de recolección de basura (que limpian la memoria automáticamente), desarrolladas por Daniel Edwards, hicieron posible usar Lisp en computadoras normales, pero la eficiencia seguía siendo un desafío. Esto llevó a la creación de las máquinas Lisp: computadoras diseñadas específicamente para ejecutar programas Lisp. Sin embargo, los avances en las computadoras y en las herramientas de programación hicieron que estas máquinas Lisp quedaran obsoletas.

Durante los años 80 y 90, se hizo un gran esfuerzo para unir los muchos dialectos de Lisp en un solo lenguaje, llamado Common Lisp. En 1994, se publicó el estándar de Common Lisp.

El Resurgimiento de Lisp en el Siglo XXI

Después de un descenso en los años 90, Lisp ha vuelto a ganar popularidad, especialmente con las versiones de código abierto de Common Lisp y el desarrollo de nuevas aplicaciones. Un ejemplo de este interés fue que el libro "Practical Common Lisp" de Peter Seibel, un tutorial para nuevos programadores, se convirtió en uno de los libros de programación más populares en Amazon.com en 2004.

Muchos nuevos programadores de Lisp se han inspirado en escritores que defienden el lenguaje, a pesar de que otros lo consideran anticuado. Estos programadores a menudo dicen que Lisp les ha abierto los ojos y que es mucho más productivo que otros lenguajes.

La comunidad de código abierto ha creado muchas herramientas de apoyo para Lisp, como wikis, directorios de recursos, canales de chat y foros. También se celebran reuniones y conferencias sobre Lisp en todo el mundo.

El dialecto Scheme también sigue siendo muy activo, con muchas implementaciones y un proceso de estandarización continuo. Aunque su uso en la enseñanza de ciencias de la computación ha disminuido un poco, sigue siendo importante.

Además, han surgido nuevos dialectos de Lisp, como Newlisp, Arc y Clojure.

Dialectos Principales de Lisp

Los dos dialectos principales de Lisp que se usan hoy en día para la programación general son Common Lisp y Scheme. Cada uno tiene un enfoque diferente en su diseño.

Common Lisp es una versión más grande y completa, que incluye muchos tipos de datos y formas de escribir código. Scheme es más simple, con menos características estándar, pero con algunas funciones especiales que no siempre se encuentran en Common Lisp. Common Lisp también ha adoptado algunas ideas de Scheme.

Scheme fue creado por Guy Lewis Steele Jr. y Gerald Jay Sussman. Fue diseñado para ser muy claro y sencillo. Permite programar de muchas maneras diferentes, como la programación funcional o la programación que usa comandos.

Otros dialectos de Lisp se usan como lenguajes de scripting (para automatizar tareas) en varias aplicaciones. Los más conocidos son Emacs Lisp en el editor de texto Emacs, Visual Lisp en AutoCAD y Nyquist en el programa de edición de audio Audacity.

¿Qué Innovaciones Aportó Lisp a la Programación?

Muchas ideas importantes en las ciencias de la computación nacieron en Lisp. Algunas de ellas son:

• Las estructuras de datos tipo árbol.
• La recolección automática de basura (limpieza de memoria).
• Los tipos de datos dinámicos (que pueden cambiar).
• Las condiciones (como "si esto, entonces aquello").
• Las funciones de orden superior (funciones que trabajan con otras funciones) como map y reduce.
• La recursividad (cuando una función se llama a sí misma).
• Los compiladores autocontenidos (programas que pueden crear otros programas).
• El REPL (un entorno interactivo para probar código).

Lisp fue el primer lenguaje de programación "homoicónico". Esto significa que el código fuente del programa es al mismo tiempo una estructura de datos del lenguaje (listas anidadas o árboles). Gracias a esto, es relativamente fácil escribir programas en Lisp que manipulen o incluso creen otros programas de Lisp. Esto se considera una de las mayores ventajas del lenguaje.

La estructura `IF THEN ELSE` (si... entonces... si no...), que es esencial en cualquier lenguaje de programación, fue inventada por McCarthy para Lisp. Luego fue adoptada por el lenguaje ALGOL, que la hizo popular.

Lisp también influyó mucho en Alan Kay, el creador de Smalltalk. A su vez, Lisp fue influenciado por Smalltalk y adoptó características de la programación orientada a objetos (como clases y objetos) a finales de los años 70.

Lisp introdujo el concepto de recolección de basura, donde el sistema busca y elimina automáticamente los datos que ya no se usan en la memoria, sin que el programador tenga que hacerlo manualmente.

Debido a que Lisp necesitaba muchos recursos de las computadoras antiguas, no se hizo tan popular fuera de la comunidad de inteligencia artificial como FORTRAN o C. Sin embargo, lenguajes más nuevos como Java y Python han incorporado algunas de las características de Lisp. Hoy en día, Lisp está volviendo a ser popular por su utilidad en aplicaciones complejas y dinámicas.

Las Listas en Lisp

El elemento más importante en Lisp es la lista. Tanto los datos como los programas se representan como listas. De ahí viene su nombre: Lisp es un acrónimo de "List Processing" (procesamiento de listas).

Las listas en Lisp se escriben entre paréntesis. Por ejemplo, `(1 2 3)` es una lista de números.

Algunas funciones de Lisp usan símbolos conocidos, como `+` para sumar o `*` para multiplicar. Pero otras tienen nombres un poco extraños, como "car" y "cdr". Estos nombres vienen de las computadoras antiguas. "Car" te da el primer elemento de una lista, y "cdr" te da el resto de la lista.

Lisp suele trabajar con los datos sin cambiarlos directamente. La mayoría de las funciones devuelven una nueva lista con el resultado, en lugar de modificar la lista original.

Una de las razones por las que Lisp es bueno para la IA es que el código y los datos se tratan de la misma manera (como listas). Esto hace que sea muy fácil escribir programas que puedan crear o modificar otros programas, dependiendo de lo que necesiten hacer.

Lisp fue uno de los primeros lenguajes en incluir el manejo de excepciones, que permite a los programas reaccionar a errores de forma controlada.

El lenguaje de programación Logo es un lenguaje derivado de Lisp. Se podría decir que Logo es como Lisp, pero sin tantos paréntesis y con las operaciones matemáticas escritas de una forma más común.

Origen de "car" y "cdr"

Los nombres "car" y "cdr" provienen de las operaciones del conjunto de instrucciones de la computadora IBM 704:

• car: Content of Address part of Register (Contenido de la parte de dirección del registro)
• cdr: Content of Decremental part of Register (Contenido de la parte de decremento del registro)

Ejemplos de Código Lisp

Aquí tienes algunos ejemplos sencillos de cómo se ve el código en Lisp:

Hola mundo

Este programa simplemente muestra un mensaje en la pantalla:

(format t "¡Hola, mundo!")

Trabajando con listas

Este ejemplo muestra cómo crear una función para saber si una lista está vacía y otra para encontrar el último elemento de una lista. También incluye una función para calcular el factorial de un número.

; Función para saber si una lista está vacía
(defun vacia (l)
  (cond ((null l) 1)    ; Si la lista es nula (vacía), devuelve 1
        (t 0)))         ; Si no, devuelve 0 (la lista no está vacía)

; Ejemplos de uso:
; (vacia '(1 3 4))  ; Devuelve 0 (la lista no está vacía)
; (vacia '())      ; Devuelve 1 (la lista está vacía)

; Función para encontrar el último elemento de una lista
(defun último (lista)
  (cond ((null (cdr lista)) (car lista)) ; Si el resto de la lista es nulo, el primer elemento es el último
        (t (último (cdr lista)))))       ; Si no, busca el último en el resto de la lista

; Ejemplo de uso:
; (último '(1 2 3 4 5 6 7)) ; Devuelve 7

; Función para calcular el factorial de un número (usando recursividad)
(defun factorial (n)
   (if (= 0 n)
     1                            ; Caso base: el factorial de 0 es 1
     (* n (factorial (- n 1)))))  ; Caso recursivo: n multiplicado por el factorial de (n-1)

; Ejemplo de uso:
; (factorial 4) ; Devuelve 24 (4 * 3 * 2 * 1)

Función de Ackermann

Este es un ejemplo de una función matemática compleja que se puede escribir en Lisp. La función de Ackermann crece muy rápido.

 ; Propuesta por Nikolai Coica
 (defun ackermann (m n) "La Función de Ackermann"
   (cond ((= m 0) (+ n 1))
         ((= m 1) (+ n 2))
         ((= m 2) (+ 3 (* n 2)))
         ((= m 3) (+ 5 (* 8 (- (expt 2 n) 1))))
         (t (cond ((= n 0) (ackermann (- m 1) 1))
                  (t (ackermann (- m 1) (ackermann m (- n 1))))))))

Galería de imágenes

• 

  Una imagen de un libro sobre programación en Lisp.

Véase también

En inglés: LISP Facts for Kids

• Inteligencia artificial
• Common Lisp
• Scheme
• Maxima