+20 Lenguajes de Programación de lo Más Extraños

Algunas personas dicen que aprender a programar es difícil, tedioso y terrible. Es como aprender un nuevo idioma, solo que para hablar con una máquina a la que hay que decirle qué hacer y ejecutar con comandos muy específicos. Por alguna razón, un grupo de personas parece pensar que la programación en sí no es lo suficientemente complicada, y así nació el ‘esolang‘.

Bienvenido al mundo de los lenguajes de programación esotéricos (también conocidos como esolang), donde los programadores desafían las convenciones del diseño de lenguajes. Estos lenguajes no están pensados para ser fáciles de usar. Al contrario, están diseñados para desafiar, frustrar y divertir a los programadores con su dificultad. Hay muchos esolangs ahí fuera para que los pruebes (de hecho aquí hay una Wiki), pero aquí tienes 25 de los más extraños y disparatados.

1. Brainfuck

Fiel a su nombre, este lenguaje de programación le dará dolor de cabeza a cualquier programador. Fue creado por Urban Müller en 1993, como un lenguaje que podía ser implementado por un compilador realmente pequeño para divertir al programador.

El lenguaje utiliza solo ocho comandos y un puntero de instrucción, cada uno compuesto por un solo carácter, lo que lo convierte en un lenguaje increíblemente minimalista. A continuación se muestra una muestra del código que induce al dolor de cabeza, uno que imprimirá ‘¡Hola Mundo!’:

>++++[<+++++++++>-]<.      // Imprime '¡' (ASCII 161)
>++++[<+++++++>-]<+.     // Imprime 'H' (ASCII 72)
>++++[<+++++++>-]<+.     // Imprime 'o' (ASCII 111)
>++[<+++++++>-]<.        // Imprime 'l' (ASCII 108)
>+++[<+++++++>-]<+.     // Imprime 'a' (ASCII 97)
>++++[<+++++++>-]<+.     // Imprime ' ' (Espacio, ASCII 32)
>++++[<+++++++>-]<.      // Imprime 'M' (ASCII 77)
>+++[<+++++++>-]<.      // Imprime 'u' (ASCII 117)
>++++[<+++++++>-]<.     // Imprime 'n' (ASCII 110)
>+++[<+++++++>-]<.      // Imprime 'd' (ASCII 100)
>++++[<+++++++>-]<.     // Imprime 'o' (ASCII 111)
>++++[<+++++++>-]<.     // Imprime '!' (ASCII 33)

2. LOLCODE

LOLCODE está hecho de lolspeak, el «idioma» utilizado por los lolcats. El lenguaje fue diseñado por Adam Lindsay en 2007, un investigador del Departamento de Informática de la Universidad de Lancaster. El lenguaje no es tan completo como los tradicionales, ya que la sintaxis y las prioridades de los operadores no están claramente definidas, pero existen compiladores que funcionan para ello.

La hilaridad y la monería del lenguaje compensan con creces esto. Basta con echar un vistazo al código ‘¡Hola Mundo!’ que aparece a continuación:

HAI 1.2
I HAS A VAR ITZ "¡Hola Mundo!"
VISIBLE VAR
KTHXBYE

3. Befunge

Similar a Brainfuck, Befunge fue desarrollado por Chris Pressey en 1993, con el objetivo de crear un lenguaje que fuera lo más difícil de compilar posible.

Lo hace implementando código automodificable y haciendo que la misma instrucción se ejecute de cuatro maneras diferentes, por no hablar del propio conjunto de instrucciones. Sin embargo, con el tiempo se crearon varios compiladores. A continuación se muestra el código fuente de ‘¡Hola Mundo!’:

>0"¡Hola Mundo!">:#,@

Explicación rápida del código:

• >0"¡Hola Mundo!": Coloca los caracteres de la cadena en el stack.
• >: Mueve el puntero a la derecha.
• :: Duplica el valor en la pila.
• #: Salta una celda.
• ,: Imprime el carácter ASCII en la parte superior del stack.
• @: Termina el programa.

4. ArnoldC

Aquí tienes un lenguaje de programación hecho enteramente con frases de películas protagonizadas por Arnold Schwarzenegger, clásicos como Terminator, Predator y Desafío total. ArnoldC fue creado por Lauri Hartikka, que cambió los comandos estándar por su equivalente en frases de Arnold.

Por ejemplo, Falso (False) y Verdadero (True), que se convierten en «I LIED» y «NO PROBLEMO», respectivamente. Así es como se vería un código de «Hola Mundo»:

IT'S SHOWTIME
  TALK TO THE HAND "Hola Mundo"
YOU HAVE BEEN TERMINATED

5. Shakespeare

Si los actores austriacos culturistas no son lo tuyo, puede que prefieras el lenguaje de programación Shakespeare. Creado por Jon Aslund y Karl Hesselstörm, el objetivo era crear un lenguaje de programación que no lo pareciera. En este caso, el código fuente tiene exactamente el mismo aspecto que una obra de Shakespeare. Las variables deben llevar el nombre de personajes de Shakespeare y las constantes se deciden mediante sustantivos positivos o negativos.

The Art of War.

Romeo: 72 111 108 97 32 77 117 110 100 111 33
Print the string.

Juliet: 0

The End.

The Art of War.: El título del programa.

Romeo: 72 111 108 97 32 77 117 110 100 111 33:

• Define una variable llamada Romeo con valores ASCII que corresponden a los caracteres de «¡Hola Mundo!».

Print the string.:

• Imprime los caracteres definidos en la variable Romeo como una cadena.

Juliet: 0:

• Define una variable llamada Juliet con el valor 0 (en este caso, no se usa).

The End.:

• Marca el final del programa.

6. Chef

Al igual que Shakespeare, Chef, creado por David Morgan-Mar, es un lenguaje de programación que no parece tal, sino una receta de cocina. Los principios de diseño del lenguaje son que

• el código no solo debe generar una salida válida, sino que la salida debe ser fácil de preparar y deliciosa
• las recetas deben atraer a cocineros con diferentes presupuestos
• las recetas tienen que ser métricas

En otras palabras, las recetas deben funcionar como código, Y pueden ser preparadas y comidas. El código fuente para el programa «Hola Mundo» está disponible a continuación:

Recipe for Hello World.

Ingredients.
1 cup of Hello
1 cup of World

Method.
Put Hello into the mixing bowl.
Put World into the mixing bowl.
Stir the mixing bowl for 1 minute.
Serve with a message "¡Hola Mundo!".

Serves 1.

7. Whitespace

Whitespace fue creado por Edwin Brady y Chris Morris como una broma del Día de los Inocentes. Mientras que la mayoría de los lenguajes de programación ignoran los caracteres de espacio en blanco, Whitespace los utiliza como comandos, ignorando en su lugar los caracteres que no son de espacio en blanco.

Debido a esto, el código Whitespace puede escribirse dentro de lenguajes de programación que ignoran los espacios en blanco. A continuación se muestra un código fuente «Hello World» escrito en Whitespace (se utiliza color para mayor claridad).

En Whitespace, el código se escribe utilizando tres caracteres invisibles:

• Espacio ()
• Tabulación (\t)
• Salto de línea (\n)

8. Piet

Llamado así por Piet Mondrian, Piet es otro lenguaje de programación esotérico creado por David Morgan-Mar. El programa se compila mediante un puntero que se desplaza por la imagen, de una sección a otra.

El código está en el color; el compilador lee los colores para convertirlos en un programa. A continuación se muestra un ejemplo de «código fuente», cuya salida es «Piet:

Fuente: Wikipedia

9. Chicken

Chicken. Este es un lenguaje de programación que consiste en una sola palabra: chicken. Fue creado por el programador sueco Torbjörn Söderstedt, quien se inspiró para crearlo después de escuchar la parodia de los discursos científicos (que nadie entiende) de Doug Zongker.

En lugar de mostrar el código de «¡Hola Mundo!», que ocuparía la mitad de la página y consistiría únicamente en la palabra «chicken», aquí tienes el documento y la presentación que inspiraron el lenguaje:

10. Ook!

Ook! es un derivado de Brainfuck, y es creado por el desarrollador de lenguaje esotérico en serie, David Morgan-Mar. La estructura es la misma, excepto que los ocho comandos se sustituyen por combinaciones de «Ook.», «Ook?» y «Ook!».

El objetivo era crear, y no es broma, un lenguaje de programación «escribible y legible por orangutanes». A continuación se muestra el código fuente de «¡Hola Mundo!»:

Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook.
Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook?
Ook! Ook! Ook? Ook! Ook? Ook. Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook.
Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook!
Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook. Ook! Ook. 

11. reMorse

Desarrollado por Ryan Kusnery, ReMorse es un lenguaje de programación que se hizo para parecerse al código Morse. Solo hay cuatro instrucciones: punto (.), punto-espacio (. seguido de un espacio), guión (-) y guión-espacio (- seguido de un espacio).

Las especificaciones de ReMorse no estaban claras, y ReMorse2 se creó como un intento de limpiar un poco el código. A continuación se muestra un ejemplo incompleto de «Hola Mundo«:

- - - ..- ...- --- -.-.-- ; "¡Hola"
- - - .-. - ..-.- ...-. ---. ; "Mundo"
-.............. ; output all characters

12. l33t

Cualquiera que haya pasado algún tiempo en Internet sabe lo que es el l33t sp34k (leet speak): los usuarios sustituyen palabras y letras por números y una ortografía deliberadamente incorrecta.

Dos programadores, Stephen McGreal y Alex Mole, decidieron que sería una buena idea crear un lenguaje de programación a partir de él y así nació l33t. Al igual que muchos otros lenguajes esotéricos, fue diseñado para que fuera lo más «abrumador posible de codificar». A continuación se muestra el código fuente de «¡Hola Mundo!»:

// "¡Hola Mundo!" en l33t speak
// Este código demuestra cómo escribir "¡Hola Mundo!" usando l33t speak.

Gr34t l33tN3$$?
M3h...
1t'5 4 h0r1z0nt4l t3xt b4$1c 1n l33t 5p34k.

¡L33t 5p34k 15 50m3th1ng 1nCr3d1bl3!
I7'5 4 w4y 70 5h0w 0ff y0ur 5k1ll$ 4nd h4v3 50m3 fun w1th c0d1ng!

1f y0u w4nn4 b3 4 l33t h4xX0r, 7h3n y0u n33d 70 pr4c71c3 m0r3 c0d3.
4ny0n3 c4n 7ry 17, bu7 1f y0u w4nn4 b3 th3 b357, y0u mu57 w0rk h4rd!

M4ny p30pl3 w4n7 70 5h0w 0ff w17h l33t 5p34k b3c4u53 17'5 4 w4y 70 r34ch 4 h1gh3r 5t4nd4rd 0f c0d1ng.

N0w l3t'5 g37 70 7h3 g00d 574ff:

|_||_| 0  |\/| 4 0  |\/| (0  |\/| 0  |\/| (0  |\/| _|3| 0  |\/| _| 0 1
H   O   L   A      M   U   N   D   O  !  

- | 4 - H
- 0 - O (cambiado por 0)
- L - L
- 4 - A (cambiado por 4)
- (espacio) - espacio normal
- |\/| - M
- (_|) - U
- |\| - N
- [) - D
- 0 - O (cambiado por 0)
- ! - !

|\/|4   | 0 |\/|   !    1s 7h3 c0d3 70 r34ch 7h3 0u7pV14n.

T3l3ph0n3 c0d3 15 0n3 0f 7h3 m05t b4$1c l33t 5p34k c0mm4nd$.

N0w y0u'v3 l34rn3d 70 c0d3 1n l33t 5p34k, 70n9 4nd g3t 7h3 m3$$4g3 0u7!

5h0w y0ur 5k1ll$ 4nd h4v3 50m3 fun! 

// ¡Hola Mundo! 15 h3r3.

13. Omgrofl

Omgrofl (que significa «oh my god rolling on the floor») fue creado por Juraj Borza, donde todos los comandos están formados por acrónimos de Internet como lol, wtf, brb, stfu, etc. Todas las variables declaradas con el lenguaje deben tener la forma de lol, por ejemplo, lol, lool, loool, etc. Así es como se ve el código fuente de «Hola Mundo»:

lol iz "Hola mundo!"
lmao lol

14. Velato

Velato es un lenguaje creado por Daniel Temkin que utiliza archivos MIDI como código fuente. Los comandos están determinados por el tono y el orden de las notas, y los códigos fuente creados con Velato tienden a tener un sonido similar al jazz.

El ejemplo de «Hello, World» que se muestra a continuación es el aspecto del «código fuente»:

15. Malbolge

Si un lenguaje de programación se llama como el octavo círculo del Infierno, ya sabes qué esperar. Creado por Ben Olmstead en 1998, Malbolge fue diseñado para que fuera casi imposible de programar.

De hecho, no fue hecho por el hombre, sino que se creó mediante un algoritmo. No es de extrañar que se tardara 2 años en materializar el programa. Este es el código fuente de «Hola Mundo» para este lenguaje de programación imposible para que te hagas una idea de la locura del código.

('&%:9]!~}|z2Vxwv-,POqLkjihg$#`Q*2@>-<~?$%(!)

Código: El código es una cadena de caracteres que Malbolge interpreta. Cada carácter en el código tiene un significado específico en el contexto del lenguaje, y el programa se basa en operaciones complejas que incluyen la manipulación de memoria y registros internos.

Ejecución: Malbolge utiliza un modelo de máquina de Turing con una serie de operaciones muy particulares que son difíciles de seguir. El código proporciona una serie de instrucciones que Malbolge ejecuta de manera enrevesada.

16. Taxi

Taxi parece un lenguaje de hoja de ruta que los viajeros encontrarán fácil de entender pero no necesariamente de codificar. Es el lenguaje de programación oficial de Townsville, donde el lenguaje de codificación tradicional ha sido sustituido por un moderno lenguaje de mapas. Las variables, clases o funciones se sustituyen por lugares o ciudades en este lenguaje.

Se trazan rutas de taxi que llevan a un pasajero de un lugar a otro y hay que dar instrucciones sobre direcciones, recogidas y dejadas. Los taxis necesitan combustible para funcionar, por lo que los pasajeros pagan por sus viajes, y se obtiene dinero en efectivo para repostar el taxi en las gasolineras.

Aquí tienes «Hola, Mundo» en lenguaje Taxi:

[ "Hola, Mundo!" ] is waiting at Writer's Depot.
Go to Writer's Depot: south 1st left.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right, 1st right.
"Hola, Mundo!"
Go to Taxi Garage: south 1st left. 

17. ZOMBIE

ZOMBIE es un lenguaje de programación diseñado para nigromantes (practicantes de magia que hablan con los muertos). Permite a sus codificadores escribir código para animar cadáveres, controlar espíritus y resolver problemas computables a través de ellos. Tiene una garantía contra la sobrescritura de la memoria del sistema y la liberación de entradas maliciosas en la Tierra.

ZOMBIE viene en forma de declaraciones de entidad. En este lenguaje, los errores de sintaxis son extremadamente peligrosos porque los demonios pueden escapar de la CPU y crear el caos en el mundo con comandos de enlace incorrectos. Sus valores de datos son de formato libre y compatibles con las reglas matemáticas estándar.

Un ejemplo para imprimir «¡Hola, Mundo!» en lenguaje ZOMBIE:

HolaMundo is a zombie
summon
  task SayHello
    say "¡Hola, Mundo!"
  animate
animate

18. BIT

BIT es un potente lenguaje de programación de bajo nivel en el que el codificador tiene acceso total a todos los datos en su implementación ASCII. La manipulación de los datos es menos complicada que en los lenguajes de alto nivel que utilizan funciones especializadas para tipos de datos abstractos. Hay dos tipos de datos en BIT: bit y dirección de un bit.

Los valores de datos en BIT pueden operarse mediante operadores y comandos. Este lenguaje está fuertemente tipado (es decir, los datos siempre se declaran junto con su tipo) e incluso soporta la controvertida instrucción de control de flujo «GOTO». BIT permite cualquier cantidad de espacios en blanco y saltos de línea entre los elementos de la sintaxis.

Un ejemplo para imprimir «¡Hola, Mundo!» en lenguaje BIT:

01101000 01101111 01110000 01101001 01101110 00100000 01101100 01100011 01110100 01101000 01101111 00100000 01101110 01100101

19. Unlambda

Unlambda es un lenguaje que mezcla los paradigmas de programación ofuscada y funcional. En este lenguaje, todo es una función, incluso los datos. Elimina varias características cruciales: no hay forma de almacenar datos o tener variables y, además, se pueden crear funciones pero no se pueden nombrar ni guardar. Vaya.

Unlambda trabaja solo con funciones: cada función toma exactamente otra función como argumento y devuelve solo una función más. Permite trabajar con estructuras de datos y similares, pero hay que representarlas como funciones ad-hoc (todo es una función, al fin y al cabo).

Un ejemplo para imprimir «¡Hola, Mundo!» en lenguaje Unlambda:

s`sii`ki
s`s`ks
s`s`ks`s`k`s`kr
s`k`s`ki`s`k`s`k
d`^^^^^^.H.o.l.a.,. .M.u.n.d.o.!
k
k
k`s`s`ksk`k.*

20. Java2K

Java2K es un lenguaje probabilístico que funciona sobre la naturaleza del universo: «nunca hay seguridad absoluta, siempre hay solo probabilidad». No hace lo que pretendes que haga; incluso las funciones incorporadas funcionan de forma extraña. Sin embargo, sí que realiza una comprobación de seguridad a nivel de código fuente y el lenguaje utiliza un sistema numérico de base 11, que cuenta hasta 9 e incluye el 10.

El programa siempre consta de 2 argumentos, incluso si solo necesitas uno. Hay dos tipos de números: nombres de los objetos y valores enteros. Para cada función de Java2K, existen varias implementaciones y cualquiera de ellas se elige aleatoriamente en tiempo de ejecución. Tiene una serie de restricciones sobre las palabras clave y funciones válidas, e incluso ofrece un recolector de basura para liberar memoria automáticamente.

Un ejemplo para imprimir «¡Hola, Mundo!» en lenguaje Java2K:

1 1 /125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2

21. Deadfish

Deadfish es un lenguaje interpretado peculiar, que fue programado originalmente en tan solo unas horas usando el lenguaje C. Deadfish tiene solo 4 comandos en total: todos para generar salidas, pero ninguno para entradas (dije que era peculiar). El lenguaje distingue entre mayúsculas y minúsculas, y solo puede manejar valores enteros al sumar o restar.

Su shell estándar no acepta nada que no sea un comando. Sin embargo, no hay forma de detectar o informar errores en tiempo de ejecución, y el shell simplemente imprime una nueva línea para cualquier error. Su nombre «Deadfish» (pez muerto) se le dio porque programar en este lenguaje se siente tan desagradable como comer pescado muerto podrido.

Un ejemplo para imprimir «¡Hola, mundo!» en lenguaje Deadfish:

iiiiiiccccciiiiiiccccccciiiiiiiiiiiiiiiiccccicccciccccciccicciiicciccicciiiiiicccciiiiccciiiiiicccccccciccicciiicciccicciiccicciiiiiiiiiiiiiiiiiiiiiicccccccccicciccccciiiiiiccccccccciccicciiicciccicciicciccicciiccicciiiiiiiiiiiiiiiiiiiiiiiccccccccc

22. Emmental

Emmental es un lenguaje de programación automodificable definido por un intérprete metacircular. Es un lenguaje basado en pila con solo 13 instrucciones y su pila solo puede contener caracteres ASCII. Aunque no se admite directamente, la ramificación condicional se puede realizar en este lenguaje utilizando la instrucción de evaluación ‘?’.

Aunque Emmental puede parecer extraño en comparación con otros lenguajes ofuscados, su semántica inglesa hace que las cosas sean menos problemáticas que otros lenguajes similares. Puedes realizar aritmética primitiva, manipulación de pila y cola (sí, también tiene una cola) y mucho más usando el lenguaje Emmental.

Un ejemplo para imprimir «¡Hola, mundo!» en lenguaje Emmental:

;#72#111#108#97#44#32#109#117#110#100#111#33$

23. Whenever

Whenever es un lenguaje sin ninguna urgencia o secuencia de ejecución: hace las cosas cuando le apetece y no según la secuencia especificada por el programador. Piensa en lo que sucederá si se envía un correo a tu jefe antes/sin verificar si hay errores ortográficos. Sí, esa pesadilla que acabas de soñar es lo que obtienes con Whenever.

Whenever no «cree» en variables o estructuras de datos porque no le importa la secuencia del programa. Sin embargo, proporciona construcciones para reasignar cosas si una línea de código en particular tiene un requisito previo que aún no está preparado. A diferencia de algunos otros lenguajes, admite cadenas y declaraciones compuestas.

Un ejemplo para imprimir «¡Hola, mundo!» en lenguaje Whenever:

1 print("¡Hola, mundo!");

24. INTERCAL

INTERCAL (también conocido como Compiler Language With No Pronounceable Acronym) es un lenguaje que critica varios lenguajes al mismo tiempo. INTERCAL hace que las cosas sean absurdas para los programadores con declaraciones de construcción como ‘PLEASE’, ‘FORGET’, ‘IGNORE’ y más. El codificador debe usar ‘PLEASE’ con la frecuencia suficiente; de lo contrario, el programa se considera descortés y el compilador informa lo mismo que un error. (No es programación a menos que haya un elemento de tortura para algunos).

INTERCAL se desarrolló de forma completamente diferente a otros lenguajes de programación. Sin embargo, a diferencia de otros lenguajes ofuscados como Unlambda y Deadfish, ofrece muchas estructuras de datos, operadores y estructuras de control. Y, sin embargo, al final del día, estos no reducen su complejidad.

Un ejemplo para imprimir «¡Hola, mundo!» en lenguaje INTERCAL:

; ¡Hola, mundo!
DO ,1 <- #123
DO ,1 SUB #1 <- #72
DO ,1 SUB #2 <- #111
DO ,1 SUB #3 <- #108
DO ,1 SUB #4 <- #97
DO ,1 SUB #5 <- #32
DO ,1 SUB #6 <- #109
DO ,1 SUB #7 <- #117
DO ,1 SUB #8 <- #110
DO ,1 SUB #9 <- #100
DO ,1 SUB #10 <- #111
DO ,1 SUB #11 <- #33
DO ,1 SUB #12 <- #10
PLEASE WRITE OUT ,1

25. Orthogonal

Orthogonal es un lenguaje de programación poco común en el que el flujo puede ir en cualquier dirección que desees. Es un experimento de prueba de concepto con un intérprete funcional. Su entorno consta de dos objetos: la cuadrícula y la pila. La cuadrícula es lo mismo que una matriz y una pila es una entidad unidimensional bien conocida.

Orthogonal, a diferencia de varios lenguajes informáticos, es un lenguaje bidimensional y su conjunto de instrucciones se divide en tres categorías: operadores, directivas y otros. El lenguaje ofrece mucha más ayuda a los codificadores que BIT, Deadfish y algunos otros. Además, también admite valores de datos y variables.

Un ejemplo para imprimir «¡Hola, mundo!» en lenguaje ortogonal:

; El programa de "¡Hola, mundo!"
0   '!' 'o' 'd' 'n' 'u' 'm' ',' ' ' 'a' 'l' 'o' 'H' '¡' s 0 c 0 ret