Vea nuestra revisión de 10 de los lenguajes de programación esotéricos más complejos.

Top 10: lenguajes de programación esotéricos más complejos y extraños

Advertencia

Es importante saber que si estás leyendo esta publicación, lo estás leyendo bajo tu propio riesgo, porque los lenguajes de programación mencionados aquí derretirán tu cerebro si intentas entenderlos . Hay más de 1000 lenguajes de programación esotéricos, sin embargo, hemos compilado el más serio y extraño de ellos solo para ti.

Un lenguaje de programación esotérico no es un lenguaje diseñado específicamente para soluciones eficientes o elegantes de problemas computacionales, sino más bien para explorar las ideas básicas detrás de la teoría de la computación o ideas extrañas como, por ejemplo, la sintaxis que recuerda a recetas. Puede pensar que las personas que diseñaron el lenguaje no tuvieron nada mejor que hacer con su tiempo, y tiene razón . 

La mayoría de los lenguajes de esta lista son "Turing Complete", un sistema "Turing Complete" significa un sistema en el que se puede escribir un programa que encontrará una respuesta (aunque sin garantías en cuanto a tiempo de ejecución o memoria), eso significa que están realmente elaborados. La usabilidad rara vez es un objetivo para los diseñadores de lenguajes de programación esotéricos, así que no se preocupe, ¡no necesita trabajar con estos lenguajes en su futuro trabajo!

Sufre con nuestra colección de 10 de los lenguajes de programación esotéricos más complejos en nuestra opinión.

10. Befunge

Intérprete de Befunge

Befunge es uno de los lenguajes de programación esotéricos bidimensionales más antiguos y famosos. Befunge fue creado en 1993 por Chris Pressey. Intentó crear un lenguaje que fuera lo más difícil de compilar posible. Sin embargo, en los años siguientes aparecieron bastantes implementaciones de este lenguaje, así como varios dialectos y modificaciones denominados Fungeoids. El idioma tiene dos dialectos principales: el Befunge-93 original y el Befunge-98 posterior. La especificación original del lenguaje restringió el tamaño de la cuadrícula en la que se debería escribir el programa, lo que significa que Befunge (a diferencia de otros lenguajes esotéricos) no es Turing completo. Pero al igual que otros lenguajes esotéricos, no tiene ningún valor práctico.

El siguiente código imprimirá: Hello World:

 >25*"!dlrow ,olleH":v
                  v:,_@
                  >  ^

9. Glass

Glass es un lenguaje de programación esotérico que combina una notación postfija poco intuitiva con una fuerte orientación a objetos, lo que requiere un extenso malabarismo de una pila principal combinada con su estructura orientada a objetos.

El siguiente código imprimirá Hello World:

{M[m(_o)O!"Hello World!"(_o)o.?]}

8. Roadrunner

Roadrunner (en español correcaminos) es un lenguaje clon de Brainfuck basado en el popular personaje de Looney Tunes Roadrunner (correcaminos), quien, como es bastante conocido, casi siempre dice '¡Meep, meep!'. El lenguaje actualmente solo tiene una implementación en forma de intérprete de Python; El intérprete en cuestión también se puede modificar fácilmente para producir un clon de Brainfuck con cualquier sintaxis (hasta cierto punto).

Para imprimir Hello World, puede utilizar el siguiente código:

mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEP meeP mEEp mEEp mEEp mEEp mEEp mEEp mEEp meeP mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp meeP mEEp mEEp mEEp meeP mEEp Meep Meep Meep Meep MeeP MEEp meeP mEEp mEEp MEEP meeP mEEp MEEP mEEp mEEp mEEp mEEp mEEp mEEp mEEp MEEP MEEP mEEp mEEp mEEp MEEP meeP mEEp mEEp MEEP Meep Meep mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp MEEP meeP MEEP mEEp mEEp mEEp MEEP MeeP MeeP MeeP MeeP MeeP MeeP MEEP MeeP MeeP MeeP MeeP MeeP MeeP MeeP MeeP MEEP meeP mEEp MEEP meeP MEEP

Aunque no es tan extraño (¿teóricamente?) Como todos los demás elementos de esta lista, merece ser incluido.

7. Fish

Online playground

> <> (se pronuncia como pez) es un lenguaje de programación esotérico bidimensional, reflexivo y basado en pila. Se inspira, entre otros, Befunge. Tiene un puntero de instrucción que se mueve a través de un mundo de cuadrícula 2D y ejecuta las instrucciones en esa cuadrícula. Cada carácter de la cuadrícula representa una operación entre los 4 tipos: aritmética, pila, E / S o navegación.

Se imprimirá el siguiente código

NaNaNaNaNaNaNaNaNaBatman!:

8>aa*3-89*6+oo:?!!\3b*aa*a+aa*3-aa*9+bb*5-aa*3-6b*ooooooo;
 ^              -1/

6. Emo

Página principal

Emo actualmente significa Emoticon Memory Offuscation y fue inventado por Dustin Luck y Sean Fife en 2010, y se inspiró en Brainfuck. Aunque Emo es un acrónimo, está escrito en mayúsculas y no en mayúsculas para resaltar la naturaleza emocional del idioma.

Como Brainfuck, Emo opera en una serie de celdas de memoria, cada una inicialmente puesta a cero. Hay un puntero que apunta inicialmente a la primera celda de memoria. Sin embargo, a diferencia de Brainfuck, hay dos registros. El primero es un registro de almacenamiento, el segundo es más un área de trabajo que es una especie de medio entre el registro de almacenamiento y la memoria. Este registro de área de trabajo no es persistente entre los comandos de lectura, por lo que si se va a guardar el valor, debe escribirse en algún lugar.

El siguiente código emo imprimirá Hello World:

:^) :o) :o) :o) :^) :^(						~Almacene 10 en la posición de memoria cero
<;^}								~iniciar el ciclo, incrementar el puntero y copiar el nuevo valor de memoria en el registro
:^) :^) :^) :^) :^) :^) :^(					~Agregue 7 al registro actual y guárdelo en la memoria
;^}								~incrementar ptr y copiar el nuevo valor de memoria al registro
:^) :^) :^) :^) :^) :^) :^) :^) :^) :^(				~Agregue 10 al registro actual y guárdelo en la memoria
;^}								~incrementar ptr y copiar el nuevo valor de memoria al registro
:^) :^) :^(							~agregue 3 al registro actual y almacénelo en la memoria
;^}								~incrementar ptr y copiar el nuevo valor de memoria al registro
:^(								~agregar 1 al registro actual y almacenar en la memoria
;-| ;-|	;-| ;-}							~más el ptr abajo 4 y copia la memoria para registrar
:-(>								~Disminuir el registro actual y almacenar en la memoria y luego volver
;^}								~incrementar ptr y copiar el nuevo valor de memoria al registro
:^) :^)	:( :@							~Incrementar el registro en 2, dolor en la memoria e imprimir 'H'
;^}								~incrementar ptr y copiar el nuevo valor de memoria al registro
:^) :@								~Incrementar el registro en 1 e imprimir 'e'
:^) :^) :^) :^) :^) :^) :^) :@					~Incrementar el registro en 7 e imprimir 'l'
:@								~imprimir 'l'
:^) :^) :^) :@							~Incrementar el registro en 3 e imprimir 'o'
:(								~almacenar registro en la memoria
;^}								~incrementar ptr y copiar el nuevo valor de memoria al registro
:^) :^) :@							~Incrementar el registro en 2 e imprimir 'W'
:(								~almacenar registro en la memoria
;-| ;-}								~Disminuya ptr dos veces y copie la memoria para registrar
:^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :^) :@	~Incrementar el registro en 15 e imprimir 'o'
:(								~almacenar registro en la memoria
;^}								~incrementar ptr y copiar el nuevo valor de memoria al registro
:@								~imprimir 'o'
:^) :^) :^) :@							~Incrementar el registro en 3 e imprimir 'r'
:-) :-) :-) :-) :-) :-) :@					~disminuir el registro en 6 e imprimir 'l'
:-) :-) :-) :-) :-) :-) :-) :-) :@				~disminuir el registro en 8 e imprimir 'd'
;^}								~incrementar ptr y copiar el nuevo valor de memoria al registro
:^) :@								~incremente el registro e imprima '!'
;^| ;@								~disminuir ptr e imprimir '\ n'

5. Thue

Thue es un lenguaje de programación esotérico inventado en 2000. Es un lenguaje matrioshka basado en la reescritura de cadenas no deterministas que el autor describe como una versión de programación restringida de un tarpit de Turing. El manual de referencia de Thue no es muy claro sobre las nuevas líneas de entrada / salida. Los intérpretes de Thue existentes tienden a generar una nueva línea después de que se activa cada regla de salida. Sin embargo, esto evita escribir programas Thue que necesitan un control más preciso de la salida (como los programas de reproducción automática que generan exactamente su propio código).

El siguiente código imprimirá Hello World:

a::=~Hello World!
::=
a

4. L33T (leet)

Leet (o L33t) es un lenguaje de programación esotérico basado libremente en Brainfuck y llamado así por la semejanza de su código fuente con el lenguaje simbólico "L33t 5p34k". Es Turing-complete y tiene la posibilidad de modificar el código automáticamente. El software escrito en el idioma puede realizar conexiones de red y, por lo tanto, puede usarse para escribir malware. [Cita requerida].

El siguiente código imprimirá Hello World en l33t:

// "Hello World" por Stephen McGreal.
// Tenga en cuenta que las opiniones expresadas en este código fuente no coinciden necesariamente con las del autor: o)

Gr34t l33tN3$$? 
M3h...
iT 41n't s0 7rIckY.

l33t sP33k is U8er keWl 4nD eA5y wehn u 7hink 1t tHr0uGh.
1f u w4nn4be UB3R-l33t u d3f1n1t3lY w4nt in 0n a b4d4sS h4xX0r1ng s1tE!!! ;p
w4r3Z c0ll3cT10n2 r 7eh l3Et3r!

Qu4k3 cL4nS r 7eh bE5t tH1ng 1n teh 3nTIr3 w0rlD!!!
g4m3s wh3r3 u g3t to 5h00t ppl r 70tAl1_y w1cK1d!!
I'M teh fr4GM4stEr aN I'lL t0t41_1Ly wIpE teh phr34k1ng fL00r ***j3d1 5tYlE*** wItH y0uR h1dE!!!! L0L0L0L!
t3lEphR4gG1nG l4m3rs wit mY m8tes r34lLy k1kK$ A$$

l33t hAxX0r$ CrE4t3 u8er- k3wL 5tUff lIkE n34t pR0gR4mm1nG lAnguidGe$...
s0m3tIm3$ teh l4nGu4gES l00k jUst l1k3 rE41_ 0neS 7o mAkE ppl Th1nk th3y'r3 ju$t n0rMal lEE7 5pEEk but th3y're 5ecRetLy
c0dE!!!!
n080DY unDer5tAnD$ l33t SpEaK 4p4rT fr0m j3d1!!!!!
50mE kId 0n A me$$4gEb04rD m1ghT 8E a r0xX0r1nG hAxX0r wH0 w4nT2 t0 bR34k 5tuFf, 0r mAyb3 ju5t sh0w 7eh wAy5 l33t ppl cAn
8E m0re lIkE y0d4!!! hE i5 teh u8ER!!!!
1t m1ght 8E 5omE v1rus 0r a Pl4ySt4tI0n ch34t c0dE.
1t 3v3n MiTe jUs7 s4y "H3LL0 W0RLD!!!" u ju5t cAn'T gu3s5.
tH3r3's n3v3r anY p0iNt l00KiNg sC3pT1c4l c0s th4t, be1_1Ev3 iT 0r n0t, 1s whAt th1s 1s!!!!!

5uxX0r5!!!L0L0L0L0L!!!!!!!

3. Malbolge

Intérprete Malbolge | Generador de código Malbolge

Malbolge es un lenguaje de programación esotérico ***** difícil de entender. Es un lenguaje diseñado para ser difícil o tal vez imposible de programar. Por ejemplo, el efecto de cualquier instrucción depende de dónde se encuentre en la memoria, todas las instrucciones se modifican automáticamente (según una tabla de permutación) y tanto el código como los datos los punteros se incrementan después de cada instrucción, lo que dificulta la reutilización de cualquier código o dato. No hay forma de inicializar la memoria excepto en uno de los 8 caracteres de instrucción, no hay operador LOAD o STORE, y los únicos operadores de memoria disponibles (ambos) funcionan en trinario y están diseñados para ser opacos.

Para mostrar Hello World en malbolge, puede usar el siguiente código:

 (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc

Malbolge no puede cumplir con la definición formal de integridad de Turing, que requiere acceso a una cantidad ilimitada de memoria.

2. JSFuck

Javascript a JSFuck transpiler  | Github

JSFuck es un estilo de programación esotérico y educativo basado en las partes atómicas de JavaScript. Utiliza solo seis caracteres diferentes para escribir y ejecutar código. No depende de un navegador, por lo que incluso puede ejecutarlo en Node.js.

JSFuck se desarrolló originalmente como parte de un concurso en línea destinado a mejorar las técnicas de omisión de seguridad. Se puede utilizar para evitar la detección de código malicioso enviado en sitios web, por ejemplo, en ataques de secuencias de comandos entre sitios (XSS). Otro uso potencial de JSFuck radica en la ofuscación del código. Se ha utilizado una versión optimizada de JSFuck para codificar jQuery, la biblioteca de JavaScript más utilizada, en una versión equivalente completamente funcional que consta de solo seis caracteres distintos.

El código JSFuck es extremadamente detallado. En el siguiente ejemplo, el código JavaScript alert(1)se transpilará al siguiente código JSFuck:

Nota impresionante

JSFuck, es JavaScript totalmente válido. Eso significa que si ejecuta JSFuck como JavaScript en el navegador o algún intérprete de JS, funcionará como JavaScript simple (al menos con el ejemplo si la alertfunción existe).

[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[
]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]
])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+
(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+
!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![
]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]
+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[
+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!!
[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![
]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[
]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![
]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(!
[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])
[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+[+!+[]]+(
!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[
])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

1. Brainfuck

Intérprete online  | Minificador Brainfuck

Brainfuck (no en mayúsculas excepto al comienzo de una oración) es un lenguaje de programación Turing-completo extremadamente mínimo con solo 8 comandos. Un programa Brainfuck tiene un puntero de bytes implícito, llamado "el puntero", que se puede mover libremente dentro de una matriz de 30000 bytes, inicialmente todos puestos a cero. El puntero en sí se inicializa para apuntar al comienzo de esta matriz.

El lenguaje de programación Brainfuck consta de ocho comandos, cada uno de los cuales se representa como un solo carácter.

Incrementa el puntero.
Disminuye el puntero.
Incrementa el byte en el puntero.
Disminuya el byte en el puntero.
Salida del byte en el puntero.
Ingrese un byte y guárdelo en el byte del puntero.
Avanzar más allá de la coincidencia ] si el byte en el puntero es cero.
Salte hacia atrás a la coincidencia [a menos que el byte en el puntero sea cero.

La semántica de los comandos Brainfuck también se puede expresar de manera sucinta en términos de C, de la siguiente manera (asumiendo que p se ha definido previamente como un char * ):

se convierte en  ++ p;
se convierte en  --pags;
se convierte en  ++ * p;
se convierte en  --*pags;
se convierte en  putchar (* p);
se convierte en  * p = getchar ();
se convierte en  while (* p) {
se convierte en  }
+++++ +++++             inicializar contador (celda # 0) a 10
[                       usar ciclo para configurar las siguientes cuatro celdas en 70/100/30/10
    > +++++ ++              agregue 7 a la celda # 1
    > +++++ +++++           agregue 10 a la celda # 2
    > +++                  agregue 3 a la celda # 3
    > +                     agregue 1 a la celda # 4
    <<<< -                  contador de decremento (celda # 0)
]                   
> ++ .                  imprimir 'H'
> + .                   imprimir 'e'
+++++ ++ .              imprimir 'l'
.                       imprimir 'l'
+++ .                   imprimir 'o'
> ++ .                  imprimir ' '
<< +++++ +++++ +++++ .  imprimir 'W'
> .                     imprimir 'o'
+++ .                   imprimir 'r'
----- - .               imprimir 'l'
----- --- .             imprimir 'd'
> + .                   imprimir '!'
> .                     imprimir '\n'

O en su forma minificada:

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

Brainfuck ignora todos los caracteres excepto los ocho comandos, +-<>[],.por lo que no se necesita una sintaxis especial para los comentarios (siempre que los comentarios no contengan los caracteres del comando).

Si crees que hay lenguajes de programación esotéricos aún peores, compártelos con la comunidad en el cuadro de comentarios.


Interesado en la programación desde los 14 años, Carlos es un programador autodidacta, fundador y autor de la mayoría de los artículos de Our Code World.

Conviertete en un programador más sociable

Patrocinadores