25 Maximum Atypical Programming Languages

by DS | Feb 3, 2023 | Etcetera | 0 comments

Some people say finding out to program is difficult, tedious and excruciating. It’s like finding out a brand new language, merely to talk to a device which will have to learn in very specific directions what to do and execute. For some reason, a host of people seems to think that programming itself isn’t subtle enough, and thus ‘esolang’ was born.

Welcome to the sphere of esoteric programming languages (aka esolang), where programmers push the conventions of language design. The ones languages are now not intended to be easy to use. Slightly the opposite, they’re designed to downside, frustrate and amuse programmers with their downside. There are many esolangs out there for you take a look at, alternatively listed below are 25 of one of the most extraordinary and insane of the lot.

.no-js #ref-block-post-29857 .ref-block__thumbnail { background-image: url(“https://assets.hongkiat.com/uploads/thumbs/250&instances;160/programming-language-to-learn-2017.jpg”); }

5 New Programming Languages to Learn

Being a developer has been a absolute best career variety for a while, and it’s hard to imagine this… Be told further

1. Brainf*ck

True to its name, this programming language will give any programmer a right away headache. It was created thru Town Müller in 1993, as a language that can be implemented thru a actually small compiler to amuse the programmer.

The language uses absolute best 8 directions and an instruction pointer, every made up of a single character, making this a surprisingly minimalistic language. Beneath is a trend of the headache-inducing code, one that may print out ‘Hello Global!’:

[ as the cell will be cleared by the loop
 >++ Add 2 to Cell #2
 >+++ Add 3 to Cell #3
 >+++ Add 3 to Cell #4
 >+ Add 1 to Cell #5
 <<<+ Upload 1 to Cellular #2
 >+ Upload 1 to Cellular #3
 >- Subtract 1 from Cellular #4
 >>+ Upload 1 to Cellular #6
 [<] Switch once more to the principle 0 cell you in finding; this may occasionally most likely
 be Mobile #1 which was cleared during the former loop
 >. Mobile #2 has price 72 which is 'H'
 >---. Subtract 3 from Mobile #3 to get 101 which is 'e'
 +++++ ++..+++. Likewise for 'llo' from Mobile #3
 >>. Mobile #5 is 32 for the space

2. LOLCODE

LOLCODE is made up of lolspeak, the ‘language’ used by lolcats. The language was designed thru Adam Lindsay in 2007, a researcher at Lancaster School’s Computing Department. The language isn’t as complete as typical ones, with syntax and operator priorities now not clearly defined alternatively there are functioning compliers for that available out there.

The hilarity and cuteness of the language further that makes up for this even though. Merely take a look at the ‘Hello Global!’ code underneath:

HAI
 CAN HAS STDIO?
 VISIBLE "Hello Global!"
 KTHXBYE

3. Befunge

Similar to Brainf*ck, Befunge was complex thru Chris Pressey in 1993, with the aim of making a language that may well be as hard to carry in combination as imaginable.

He does this thru enforcing self-modifying code and having the identical instruction being completed in 4 different ways, not to indicate the instruction set itself. Then again, quite a lot of compilers were in the long run created. Beneath is the provision code for ‘Hello Global!’:

 > v
 v ,,,,,"Hello"48*, v
 v,,,,,,"Global!"25*,@

4. ArnoldC

Right here’s a programming language made absolutely out of one-liners from movies that comes with Arnold Schwarzenegger, classics harking back to Terminator, Predator and Common Recall. ArnoldC was created thru Lauri Hartikka, who swapped out usual directions with their equivalent Arnold one-liner.

Example incorporates False and True, which becomes “I LIED” and “NO PROBLEMO”, respectively. Proper right here’s how a “Hello Global!” code would seem to be:


 IT'S SHOWTIME
 TALK TO THE HAND "Hello Global!"
 YOU HAVE BEEN TERMINATED

5. Shakespeare

If bodybuilding Austrian actors isn’t your issue, it’s essential to need the Shakespeare programming language. Created thru Jon Aslund and Karl Hesselstörm, the aim was to make a programming language that didn’t seem to be one. In this case, the provision code seems exactly like a Shakespeare play. Variables should be named after Shakespearian characters and constants are decided thru certain or harmful nouns.

A “Hello Global!” trend is moderately long, learning exactly like a play, so that is absolute best part of the provision code (the entire one is available right here):


 The Infamous Hello Global Program.
 
 Romeo, a young man with a remarkable patience.
 Juliet, a likewise more youthful woman of exceptional grace.
 Ophelia, a remarkable woman so much in dispute with Hamlet.
 Hamlet, the flatterer of Andersen Insulting A/S.
 
 
 Act I: Hamlet's insults and flattery.
 
 Scene I: The insulting of Romeo.
 
 [Enter Hamlet and Romeo]
 
 Hamlet:
 You lying foolish fatherless huge smelly half-witted coward!
 You might be as foolish as the difference between a handsome rich brave
 hero and thyself! Speak about your ideas!
 
 You might be as brave since the sum of your fat little crammed misused dusty
 old-fashioned rotten codpiece and a ravishing honest warmth peaceful sunny summer time's
 day. You might be as healthy as the difference between the sum of the
 sweetest reddest rose and my father and yourself! Speak about your ideas!
 
 You might be as cowardly since the sum of yourself and the difference
 between a big mighty proud kingdom and a horse. Speak about your ideas.
 
 Speak about your ideas!
 
 [Exit Romeo]

6. Chef

Similar to Shakespeare, Chef, created thru David Morgan-Mar, is a programming language that doesn’t seem to be one, taking a look as an alternative like a cooking recipe. The design concepts of the language is that

the code should now not absolute best generate professional output alternatively the output should be easy to arrange and delicious
recipes appeal to cooks with different budgets
the recipes will have to be metric

In several words, the recipes should artwork as code, AND may also be in a position and eaten. The provision code for the ‘Hello Global!’ program is available underneath:


 Hello Global Souffle.
 
 This recipe prints the immortal words "Hello world!", 
 in a mainly brute drive manner.
 It moreover makes a lot of foods for one particular person.
 
 Elements.
 72 g haricot beans
 101 eggs
 108 g lard
 111 cups oil
 32 zucchinis
 119 ml water
 114 g pink salmon
 100 g dijon mustard
 33 potatoes
 
 Approach.
 Put potatoes into the mixing bowl.
 Put dijon mustard into the mixing bowl.
 Put lard into the mixing bowl.
 Put pink salmon into the mixing bowl.
 Put oil into the mixing bowl. Put water into the mixing bowl.
 Put zucchinis into the mixing bowl. Put oil into the mixing bowl.
 Put lard into the mixing bowl. Put lard into the mixing bowl.
 Put eggs into the mixing bowl. Put haricot beans into the mixing bowl.
 Liquefy contents of the mixing bowl.
 Pour contents of the mixing bowl into the baking dish.
 
 Serves 1.

7. Whitespace

Whitespace was created thru Edwin Brady and Chris Morris as an April Fools’ shaggy dog story. Where most programming languages put out of your mind about whitespace characters, Whitespace uses them as directions, ignoring non-whitespace characters as an alternative.

On account of this, Whitespace code may also be written inside programming languages that put out of your mind about whitespace. Beneath is a ‘Hello Global!’ provide code written in Whitespace (color is used for clarity).

Wikipedia

8. Piet

Named after Piet Mondrian, Piet is however some other esoteric programming language created thru David Morgan-Mar. The program is compiled thru a pointer that may switch around the image, from one section to the other.

The code is inside the color; the colors is be taught during the compiler to change into a program. Beneath is an example of a ‘provide code’, with the output being ‘Hello Global!’:

Wikipedia

9. Hen

Rooster. This is a programming language consisting of only one word: rooster. It was created thru Swedish programmer Torbjörn Söderstedt, who was inspired to create it after paying attention to Doug Zongker’s parody of clinical speeches (which no person understands).

Slightly than showing the code for ‘Hello Global!’, which may take half of of the internet web page and surround now not anything else alternatively the word ‘rooster’, this is the paper and presentation that inspired the language:

10. Ook!

Ook! is a derivative of Brainf*ck, and is created thru serial esoteric language developer, David Morgan-Mar. The development is the same, except the 8 directions are substituted with combinations of “Ook.”, “Ook?” and “Ook!”.

The aim was to create, and we kid you now not, a programming language “writable and readable thru orangutans”. Beneath is the provision code for ‘Hello Global!’:


 Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook.
 Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook?
 Ook! Ook! Ook? Ook! Ook? Ook. Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook.
 Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
 Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
 Ook! Ook! 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

Complex thru Ryan Kusnery, ReMorse is a programming language that was made to seem to be Morse code. There are absolute best 4 instructions: dot (.), dotty (. followed thru a space), dash (-) and dasher (- followed thru a space).

The specifications of ReMorse were unclear, and ReMorse2 was created as an attempt to clean the code up relatively. Beneath is an incomplete trend for ‘Hello Global!”:


 - - - ..- ...-.---.;newline
 - - - .-. - ..-.- ...-. ---.;!
 - - - ...- . . -.---.;d
 ----. . . -.---.;l
 ----. . -...---.;r
 ----. -...---.;o
 ----...-.- ..-. ---.;W
 overlooked code for "Hello " is similar to the above for "Global!"
 -..............;output all characters

12. l33t

Someone who has ever spent even relatively of time on the internet is conscious about what l33t sp34k (leet communicate) is — consumers substitute words and letters with numbers and intentionally bad spelling.

Two programmers, Stephen McGreal and Alex Mole, decided that it may well be a good idea to create a programming language out of it and thus l33t was born. As with many alternative esoteric languages, it was designed to be as “brain-melting as imaginable to code in”. Beneath is the provision code for ‘Hello Global!’:


 // "Hello Global" thru Stephen McGreal.
 // Bear in mind that the views expressed in this provide code
 // do not necessarily coincide with those of the writer :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 alternatively 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!!!!!!!

13. Omgrofl

Omgrofl (which stands for ‘oh my god rolling on the ground’) was created thru Juraj Borza where all of the directions are made up of web acronyms harking back to lol, wtf, brb, stfu, and so forth. All variables declared with the language should be inside the kind of lol, e.g. lol, lool, loool, and so forth. Proper right here’s what the provision code for ‘Hello Global!’ seems like:


 loool iz lol
 looooool iz lool
 rtfm
 wtf looooool iz liek 0 
 tldr
 brb
 lmao loool
 roflmao looooool
 brb

14. Velato

Velato is a language created thru Daniel Temkin which uses MIDI data since the provide code. The directions are determined during the the pitch and order of notes and the provision codes created using Velato tend to have a jazz-like sound to them.

The ‘Hello Global!” example given underneath is what the ‘provide code’ seems like:

Daniel Temkin

15. Malbolge

If a programming language is referred to as after the eighth circle of Hell, you recognize what to expect. Created thru Ben Olmstead in 1998, Malbolge was designed to be near-impossible to program it.

In truth, it was now not manmade — it’s created using an algorithm. It’s no wonder that it took 2 years for the program to materialize. That’s the provide code for ‘Hello Global!’ for this now not imaginable programming language to get a hold of an idea of the craziness inside the code.

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

16. Taxi

Taxi seems like a roadmap language that freeway travellers will to search out easy to snatch alternatively now not necessarily to code. It is the respected programming language of Townsville, where the standard coding language has been modified thru a modern map language. Variables, classes or functions are modified thru places or cities in this language.

You map out taxi routes that ferry a passenger from one place to some other and likewise you’re required to give instructions about directions, pickups and drop offs. The taxis need gasoline to run due to this fact passengers pay for their rides, and likewise you get cash for refueling your taxi at the gas stations.

Proper right here’s “Hello, Global!” in Taxi language:

"Hello, Global!" is in a position at the Writer's Depot.
Transfer to Writer's Depot: west 1st left, second correct, 1st left, second left.
Pickup a passenger going to the Post Office.
Transfer to the Post Office: north 1st correct, second correct, 1st left.
Transfer to the Taxi Garage: north 1st correct, 1st left, 1st correct.

17. ZOMBIE

ZOMBIE is a programming language designed for necromancers (magic practitioners who keep in touch to the dead). It shall we in its coders to write down code to animate dead our our bodies, control spirits and treatment computable problems via them. It has a be certain that towards overwriting tool memory and freeing malicious entries onto the Earth.

ZOMBIE comes inside the kind of entity declarations. In this language, syntax errors are extremely dangerous because of demons would perhaps break out the CPU and create havoc in the world with incorrect binding directions. Its wisdom values are loose construction and suitable with usual mathematics rules.

An example for printing “Hello, Global!” in ZOMBIE language:

HelloWorld is a zombie
summon
	job SayHello
		say "Hello, Global!"
	animate
animate

18. BIT

BIT is an impressive low-level programming language where the coder gets whole get right to use to all of the wisdom in its ASCII implementation. The manipulation of knowledge is more practical than high-level languages using specialized functions for abstract wisdom types. There are two wisdom types in BIT: bit and address-of-a-bit.

The guidelines values in BIT may also be operated using operators and directions. This language is strongly typed (i.e., wisdom is always declared together with its kind) and even is helping the arguable “GOTO” float control command. BIT shall we in any amount of whitespace and line breaks between syntax portions.

An example for printing “Hello, Global!” in BIT language:

LINE NUMBER ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ONE
LINE NUMBER ONE CODE PRINT ZERO GOTO ONE ZERO
LINE NUMBER ONE ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ZERO
LINE NUMBER ONE ZERO CODE PRINT ONE GOTO ONE ONE
LINE NUMBER ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE
LINE NUMBER ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ZERO
LINE NUMBER ONE ONE ZERO CODE PRINT ONE GOTO ONE ZERO ZERO
LINE NUMBER ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE
LINE NUMBER ONE ZERO ONE ONE CODE PRINT ZERO GOTO VARIABLE ONE
LINE NUMBER ONE ONE ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE
LINE NUMBER ONE ZERO ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO
LINE NUMBER ONE ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ZERO ZERO
LINE NUMBER ONE ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO
LINE NUMBER ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE
LINE NUMBER ONE ZERO ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE
LINE NUMBER ONE ONE ZERO ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE
LINE NUMBER ONE ONE ONE ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ONE
LINE NUMBER ONE ZERO ONE ZERO ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ZERO
LINE NUMBER ONE ZERO ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE
LINE NUMBER ONE ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ZERO ONE ZERO
LINE NUMBER ONE ONE ZERO ONE ZERO CODE VARIABLE ONE EQUALS ONE ONE ONE ZERO ZERO GOTO ONE
LINE NUMBER ONE ONE ONE ZERO ZERO CODE VARIABLE ONE EQUALS ONE ZERO ZERO ZERO ONE GOTO ONE
LINE NUMBER ONE ZERO ZERO ZERO ONE CODE VARIABLE ONE EQUALS ONE ONE ONE ONE ZERO ONE GOTO ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ZERO ONE ZERO ZERO
LINE NUMBER ONE ZERO ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ZERO ZERO ZERO
LINE NUMBER ONE ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ZERO
LINE NUMBER ONE ZERO ZERO ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ONE ONE
LINE NUMBER ONE ZERO ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ONE ZERO ONE ONE ONE
LINE NUMBER ONE ONE ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE ONE
LINE NUMBER ONE ONE ONE ZERO ONE ONE CODE PRINT ZERO GOTO VARIABLE ONE
LINE NUMBER ONE ONE ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZEROZERO ONE ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ZERO ONE ONE
LINE NUMBER ONE ZERO ONE ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ZERO ONE
LINE NUMBER ONE ZERO ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE ZERO
LINE NUMBER ONE ZERO ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE ONE
LINE NUMBER ONE ONE ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ZERO ONE
LINE NUMBER ONE ONE ZERO ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE ZERO
LINE NUMBER ONE ONE ZERO ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ONE ZERO ZERO ONE
LINE NUMBER ONE ONE ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE ZERO
LINE NUMBER ONE ONE ONE ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO ZERO
LINE NUMBER ONE ONE ONE ONE ZERO ZERO CODE PRINT ONE GOTO ONE ZERO ZERO ZERO ONE ONE
LINE NUMBER ONE ZERO ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ZERO ONE
LINE NUMBER ONE ZERO ZERO ONE ZERO ONE CODE PRINT ONE GOTO ONE ZERO ZERO ONE ONE ZERO
LINE NUMBER ONE ZERO ZERO ONE ONE ZERO CODE PRINT ONE GOTO ONE ZERO ONE ZERO ZERO ONE
LINE NUMBER ONE ZERO ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ZERO ONE ZERO ONE ZERO
LINE NUMBER ONE ZERO ONE ZERO ONE ZERO CODE VARIABLE ONE EQUALS ONE ZERO ONE ONE ZERO ZERO GOTO ONE ONE
LINE NUMBER ONE ZERO ONE ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ZERO ONE
LINE NUMBER ONE ONE ZERO ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ZERO ZERO ONE ZERO
LINE NUMBER ONE ONE ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ZERO ONE ZERO ZERO
LINE NUMBER ONE ONE ZERO ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ZERO ZERO ZERO
LINE NUMBER ONE ONE ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ZERO ONE
LINE NUMBER ONE ZERO ZERO ZERO ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ONE ZERO
LINE NUMBER ONE ZERO ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ZERO ZERO ONE ZERO ZERO
LINE NUMBER ONE ZERO ZERO ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ZERO ZERO
LINE NUMBER ONE ZERO ONE ZERO ZERO ZERO CODE VARIABLE ONE EQUALS ONE ONE ZERO ZERO ZERO ZERO GOTO ONE
LINE NUMBER ONE ONE ZERO ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ZERO ZERO ZERO ZERO
LINE NUMBER ONE ZERO ZERO ZERO ZERO ZERO CODE PRINT ONE GOTO ONE ZERO ONE ONE ONE ONE ONE
LINE NUMBER ONE ZERO ONE ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE ONE ONE
LINE NUMBER ONE ONE ZERO ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ONE ZERO ONE ONE ONE
LINE NUMBER ONE ONE ONE ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO ONE ONE
LINE NUMBER ONE ONE ONE ONE ZERO ONE ONE CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ZERO ONE
LINE NUMBER ONE ONE ONE ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ONE ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ONE ONE ONE
LINE NUMBER ONE ZERO ONE ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ZERO ONE ONE
LINE NUMBER ONE ZERO ONE ONE ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE ZERO ONE
LINE NUMBER ONE ZERO ONE ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE ONE ZERO
LINE NUMBER ONE ZERO ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE ONE ONE
LINE NUMBER ONE ONE ZERO ZERO ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ZERO ONE ONE
LINE NUMBER ONE ONE ZERO ONE ZERO ONE ONE CODE PRINT ONE

19. Unlambda

Unlambda is a language mix of obfuscated and sensible programming paradigms. In this language, the whole thing is a function – even the tips. It removes fairly a large number of an important choices: there is no technique to store wisdom or have variables, and moreover, you are able to create functions alternatively can’t name or save them. Oops.

Unlambda works absolute best with functions: every function takes exactly one some other function as a topic and returns just one however some other function. It does allow operating with wisdom buildings and the like, alternatively you’ll have to represent them as ad-hoc functions (the whole thing is a function, in spite of everything).

An example for printing “Hello, Global!” in Unlambda language:

```s``sii`ki
``s``s`ks
``s``s`ks``s`k`s`kr
``s`k`si``s`k`s`k
`d````````````.H.e.l.l.o.,. .W.o.r.l.d.!
k
k
`k``s``s`ksk`k.*

20. Java2K

Java2K is a probabilistic language that works on the nature of the universe: “there is on no account absolute protection, there is always absolute best chance.” It doesn’t do regardless of you intend for it to do; even the built-in functions artwork extraordinary. Then again, it does source-code level checking for protection and the language uses an 11-based amount tool – counting up to 9 and at the side of 10.

The program always consists of 2 arguments – even if you need just one. There are two types of numbers: names of the units and integer values. For every function in Java2K, there are fairly a large number of implementations and any of them is chosen randomly at the runtime. It has quite a lot of restrictions on professional keywords and functions, and the language even provides a garbage collector to auto-release memory.

An example for printing “Hello, Global!” in Java2K language:

1 1 /125 /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/*/
_/_/131 /119 /125 /11 6/*/_/_/125 /13 2/*/
_/_/131 /119 /125 /11 6/*/_/_/125 /13 2/*/
_/_/119 /125 /11 6/*/_/_/125 /13 2/*/_/_
/*1 1 /125 /119 /11 6/*/_/13 2/*/_/
125 /131 /119 /125 /11 6/*/_/_/125 /13 2/*/_
/_/119 /125 /11 6/*/_/_/125 /13 2/*/_/_
/125 /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/*/_/_
/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/*/_/_
/*1 1 /125 /131 /119 /125 /11 6/*/_/_
/125 /13 2/*/_/_/119 /125 /11 6/*/_/_/
125 /13 2/*/_/_/125 /131 /119 /125 /11 6/*/
_/_/125 /13 2/*/_/_/131 /119 /125 /11 6/*/
_/_/125 /13 2/*/_/_/119 /125 /11 6/*/_/_
/125 /13 2/*/_/_/125 /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/*/_/_/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/*/_/_/*1 1 /125 /131 /
119 /125 /11 6/*/_/_/125 /13 2/*/_/_/119 /
125 /11 6/*/_/_/125 /13 2/*/_/_/125 /
131 /119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
131 /119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
125 /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/*/_/_
/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/*/_/_
/*1 1 /125 /119 /11 6/*/_/13 2/*/_/
125 /119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
125 /131 /119 /125 /11 6/*/_/_/125 /13 2/*/_
/_/119 /125 /11 6/*/_/_/125 /13 2/*/_/_
/125 /131 /119 /125 /11 6/*/_/_/125 /13 2/*/_
/_/131 /119 /125 /11 6/*/_/_/125 /13 2/*/_
/_/119 /125 /11 6/*/_/_/125 /13 2/*/_/_
/125 /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/*/_/_
/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/*/_/_
/*1 1 /125 /131 /119 /125 /11 6/*/_
/_/125 /13 2/*/_/_/119 /125 /11 6/*/_/_/
125 /13 2/*/_/_/125 /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/*/_/_/131 /119 /125 /11 6/*/_/
_/125 /13 2/*/_/_/119 /125 /11 6/*/_/_/
125 /13 2/*/_/_/*1 1 /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/*/_/_/*1 1 /125 /
119 /11 6/*/_/13 2/*/_/125 /119 /125 /11 6/*
/_/_/125 /13 2/*/_/_/125 /131 /119 /125 /
11 6/*/_/_/125 /13 2/*/_/_/119 /125 /11 6/
*/_/_/125 /13 2/*/_/_/125 /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/*/_/_/131 /119 /
125 /11 6/*/_/_/125 /13 2/*/_/_/131 /119 /
125 /11 6/*/_/_/125 /13 2/*/_/_/119 /125 /
11 6/*/_/_/125 /13 2/*/_/_/*
1 1 /125 /119 /11 6/*/_/13 2/*/_/125 /119 /
125 /11 6/*/_/_/125 /13 2/*/_/_/125 /131 /
119 /125 /11 6/*/_/_/125 /13 2/*/_/_/119 /
125 /11 6/*/_/_/125 /13 2/*/_/_/125 /
131 /119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
131 /119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
125 /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/*/_/_
/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/*/_/_
/*1 1 /125 /119 /125 /11 6/*/_/_/
125 /13 2/*/_/_/125 /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/*/_/_/125 /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/*/_/_/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/*/_/_/*1 1 /125 /131 /
119 /125 /11 6/*/_/_/125 /13 2/*/_/_/119 /
125 /11 6/*/_/_/125 /13 2/*/_/_/125 /
131 /119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
131 /119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
119 /125 /11 6/*/_/_/125 /13 2/*/_/_/
125 /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/*/_/_
/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/*/_/_
/*1 1 /125 /131 /119 /125 /11 6/*/_/_/
125 /13 2/*/_/_/119 /125 /11 6/*/_/_/125 /
13 2/*/_/_/125 /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/*/_/_/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/*/_/_/*

21. Deadfish

Deadfish is an extraordinary interpreted language, which was to start with programmed in merely few hours using the C language. Deadfish has merely 4 directions in general: interested by outputting problems alternatively none for inputting problems (I did say it was extraordinary). The language is case-sensitive, and it’ll deal absolute best with integer values while together with or subtracting.

Its usual shell doesn’t accept the remaining that’s now not a command. Then again, there is no manner of catching or reporting errors at runtime, and the shell simply prints a newline for any error. Its name “Deadfish”, was given because of programming in this language feels as unpleasant as eating rotten dead fishes.

An example for printing “Hello, Global!” in Deadfish language:

iisiiiisiiiiiiiioiiiiiiiiiiiiiiiiiiiiiiiiiiiiioiiiiiiiooiiio
dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo
dddddddddddddddddddddsddoddddddddoiiioddddddoddddddddo

22. Emmental

Emmental is a self-modifying programming language defined thru a meta-circular interpreter. It’s a stack-based language with merely 13 instructions and its stack would perhaps absolute best include ASCII characters. Even if now not supported instantly, conditional branching may also be performed in this language using the eval instruction ‘?’.

Even if Emmental would perhaps look alien in comparison with other obfuscated languages, its English semantics make problems a lot much less difficult than other such languages. You are able to do primitive arithmetic, stack and queue manipulation (certain, it has got one queue too) and much more using Emmental language.

An example for printing “Hello, Global!” in Emmental language:

;#58#126#63#36!;#46#36#!;#0no 1!;#0#2!;#0#3!;#0#4!;#0#5!;#0#6!;#0#7!#0#33#100#108#114#111#119#32#44#111#108#108#101#72$

23. Each and every time

Each time is a language without any urgency or execution assortment: it does problems on each instance it seems like it and now not in step with the gathering specified by the programmer. Merely call to mind what will happen if a mail on your boss is distributed faster than/without checking for spelling mistakes. Positive, that nightmare you merely dreamt up is what you get with Each and every time.

Each and every time doesn’t “consider” in variable or wisdom buildings because it doesn’t take care of program assortment. Then again, it does provide constructs to reassign problems if a decided on line of code have a prerequisite that’s now not however in a position. No longer like a few other languages, it does reinforce strings and compound statements.

An example for printing “Hello, Global!” in Each and every time language:

1 print("Hello, Global!");

24. INTERCAL

INTERCAL (aka Compiler Language With No Pronounceable Acronym) is a language that criticizes fairly a large number of languages at the equivalent time. INTERCAL makes problems absurd for programmers with compile statements like ‘PLEASE’, ‘FORGET’, ‘IGNORE’ and additional. The coder should use ‘PLEASE’ steadily enough else the program is thought of as impolite and the compiler tales the identical as an error. (It’s now not programming aside from there’s a part of torture for some.)

INTERCAL was complex completely different from other programming languages. Then again, now not like other obfuscated languages like Unlambda and Deadfish, it does offer quite a lot of wisdom buildings, operators and control buildings. And however, at the end of the day, the ones do not reduce its complexity.

An example for printing “Hello, Global!” in INTERCAL language:

DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #108
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #194
DO ,1 SUB #7 <- #48
PLEASE DO ,1 SUB #8 <- #22
DO ,1 SUB #9 <- #248
DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #162
PLEASE READ OUT ,1
PLEASE GIVE UP

25. Orthogonal

Orthogonal is an strange programming language wherein the float can move in any route your need. It’s a proof-of-concept experiment with a operating interpreter. Its setting consists of two units: the grid and the stack. The grid is the same as an array and a stack is a widely known one-dimensional entity.

Orthogonal, now not like fairly a large number of computer languages, is a 2-dimensional language and its instruction set falls into 3 categories: operators, directives and others. The language provides much more help to the coders than BIT, Deadfish and a few others. Moreover, it moreover is helping wisdom values and variables.

An example for printing “Hello, Global!” in Orthogonal language:

0 'd' 'l' 'r' 'o' 'w' ' ' ',' 'o' 'l' 'l' 'e' 'h' s 0 c 0 ret

The put up 25 Maximum Atypical Programming Languages gave the impression first on Hongkiat.

WordPress Website Development

Supply: https://www.hongkiat.com/blog/bizarre-insane-programming-languages/

[ continue ]

How To Take a look at Your Packages With Jest

Try The Divi 5 Alpha Demo Today!

Instagram Launches DM-Based totally Buying groceries Gear For Companies: Why We Noticed It Coming [N...

WordPress Maintenance Plans | WordPress Hosting

Submit a Comment Cancel reply

You must be logged in to post a comment.

Get WordPress Maintenance & Hosting

Latest

Browse Articles