nyuuzyou/wikis huggingface dataset:
Joke computer programming language

Joke computer programming language or JCPL is an esolang created by User:None1, it runs on an imaginary joke 1-bit binary computer.
==Memory model==
It has a tape with 2 bits and a memory pointer initially at the first bit. In the beginning, the program (represented as binary bits) itself is written into the tape from the first bit to the second, bits that are not written stay 0. It can be seen that a program in JCPL has to be at most 2 bits long, so there are only 7 valid programs.
==Commands==
There are only two commands, represented by the binary bit 0, and 1.
0	Bitwise not current bit
1	Move the pointer to the other bit
For instance, take this program:
 01
as an example
Initially, the tape is:
 01
 ^
In the first command 0, the first bit is negated, thus becomes:
 11
 ^
In the second command 1, the pointer moves to the second bit, thus becomes:
 11
 ^
==Interpreter==
===Python===
c=input()
if len(c)>2:
 raise SyntaxError('Invalid program')
tape=[]
for i in c:
 if i in '01':
 tape.append('01'.index(i))
 else:
 raise SyntaxError('Invalid program')
while len(tape)<2:
 tape.append(0)
p=0
for i in range(len(c)):
 if i:
 p=1-p
 else:
 tape[p]=1-tape[p]
Category:Languages
Category:No IO
Category:Finite state automata
Category:Unusable for programming
Category:Self-modifying
Category:Implemented
Jolf

Jolf is a prefix-notation language that transpiles to JavaScript, made by User:Conor O'Brien. You can find an interpreter here and spotty documentation here.
== Language Overview ==
Every character does something. Simple, right? A character can be one of the following types:
* Control character. This character is used to provide control flow to the program.
* Operator character. This character "consumes" arguments and returns something based on the arguments.
* Data character. This character can be used as information for an operator character.
* Modifying character. These characters do actions, but do not count as data or operators. These commonly change the way in which the Jolf code is parsed, e.g., String mode.
* Substitution character. This is a character that directly transpiles to something else. Their use is discouraged.
=== Language Features ===
List of general abilities of Jolf.
* Implicit printing. If nothing has been printed, Jolf will print the last item evaluated.
* Direct transpiling. Using the $ character, you can directly insert JavaScript code. (This trivially proves Jolf's state of Turing completeness.)
== Example Programs ==
=== Hello, World! ===
"Hello, World!
The string closes implicitly and is implicitly outputted.
=== Quine ===
Cheating variant:
q
q is the programs source code.
Proper quine:
Q«Q«
Doubles the string `Q«`--the guillemets are directional strings.
Regular variants:
1
5
"e" // with pretty printing enabled
=== Cat ===
For one item:
i
Takes input, implicit output.
For an arbitrary amount of items:
oH1WH)aoHm~}
oH1 set H to 1
 WH) while(H){
 a alert (print)
 oH and set H =
 m~ a new prompt instance, executed
 } }
Category:LanguagesCategory:Turing_completeCategory:Golfing_language
Category:2015
Jot

Jot (pronounced /dʒɑt/) is a Turing tarpit designed by Chris Barker, described as "a better Gödel-numbering" than its "sister language" Iota. It is based on combinatory logic. Every combination of 0's and 1's is a syntactically valid Jot program, including the null program.
== Semantics of Jot ==
 [] -> I
 [F0] -> [F]SK
 [F1] -> λx.λy.[F](xy) -> S(K[F])
(Above, [F] converts the Jot program F into lambda calculus/combinatory logic)
== Converting combinatory logic to Jot ==
 {K} -> 11100
 {S} -> 11111000
 {AB} -> 1{A}{B}
(Above, {X} converts the combinatory logic expression X into Jot)
Note that to make the {AB} rule work, this translation satisfies the stronger property [F{A}] = [F](A).
This proves Jot is Turing-complete.
==Related languages==
* Iota, Jot's "sister language", described in the same article.
* Zot, Jot with I/O.
* Jottary, unary variant of Jot.
==External resources==
* Jot: a better Goedel-numbering (archived version)
* wikipedia:Iota and Jot
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Functional paradigm
Category:No IO
Category:Implemented
Category:2001
Jottary

Jottary (pronounced /dʒɑteri/) is a Turing tarpit described as "an even better Gödel-numbering" than its sister's Jot "sister language" Iota. It is based on combinatory logic. Every combination of 1's is a syntactically valid Jottary program, including the null program.
== Semantics of Jottary ==
 [] -> I
 [11...12n] -> S(K[1n-1])
 [11...12n+1] -> (([1n]S)K)
(Above, [1...1] converts the Jottary program 1...1 into lambda calculus/combinatory logic)
== Converting Jot to Jottary ==
For a binary Jot string b:
 [b] -> 1dec(1b)-1
This proves Jottary is Turing-complete.
==Related languages==
* Jot, Jottary's binary "sister language"
* Iota, Jottary's sister's "sister language"
* Zot, Jot with I/O.
==External resources==
* Unary Combinatory logic
* wikipedia:Iota and Jot
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Functional paradigm
Category:Joke languages
Category:Zero-dimensional
Category:No IO
Category:Implemented
Category:2023
Jug

Jug is an esoteric programming language created by User:Marz. Inspired by Liquid and the Die Hard Water Puzzle, Jug involves pouring water between different jugs in order to accomplish integer arithmetic.
==Language overview==
Jug has 8 functions, which are called like so:
 function(a,b);
Each function returns a value, meaning a function can be called with another function as a parameter.
Strings can be concatenated with ampersands, and can include numbers, like so:
 99&" bottles of beer on the wall."
Strings cannot be stored in jugs, as they are not liquid.
==Commands==
Function 	Description
jug(x,y); 	Creates Jug x (int), of size y (int). Returns x.
fill(x); 	Fills Jug x (int). Returns x.
empty(x); 	Empties Jug x (int). Returns x.
pour(x,y); 	Pours water from Jug x (int) into Jug y (int), stopping before Jug y overflows. Returns the volume of water poured (int).
echo(x); 	Prints x (string). Returns x.
volume(x); 	Returns the volume of water in Jug x (int).
Flow control 	Flow control
if_empty(x){};	If Jug x is empty, {...}. Returns x.
else{}; 	Follows if_empty(x) statement. If Jug x is not empty, {...}. Returns x.
drain(x){}; 	Loops until Jug x (int) is empty. Returns x.
==Arithmetic==
===Addition===
4+3
 jug(0,4);
 jug(1,3);
 jug(2,100);
 fill(0);
 fill(1);
 pour(0,2);
 pour(1,2);
 echo(volume(2));
===Subtraction===
7-2
 jug(0,7);
 jug(1,2);
 fill(0);
 pour(0,1);
 echo(volume(0));
===Multiplication===
4*6
 jug(0,4);
 jug(1,6);
 jug(2,1);
 jug(3,100);
 fill(0);
 drain(0){
 fill(1);
 pour(1,3);
 pour(0,2);
 empty(2);
 }
 echo(volume(3));
==Examples==
===Hello, World!===
 echo("Hello, world!");
===Fibonacci sequence===
 jug(0,20);
 jug(1,1);
 jug(2,5000);
 jug(3,5000);
 jug(4,5000);
 fill(1);
 pour(1,3);
 empty(1);
 echo("0\n1\n");
 drain(fill(0)){
 	pour(2,empty(4));
 	pour(3,4);
 	echo(volume(4)&"\n");
 	pour(3,empty(2));
 	pour(4,empty(3));
 	pour(0,1);
 	empty(1);
 }
===99 bottles of beer===
 jug(0,99);
 jug(1,1);
 drain(0){
 	echo(volume(0)&" bottles of beer on the wall,\n";
 	echo(volume(0)&" bottles of beer.\nTake one down, pass it around,\n");
 	pour(0,1);
 	empty(1);
 	if_empty(0) echo("No bottles of beer on the wall.");
 	else echo(volume(0)&" bottles of beer on the wall.");
 }
Category:Languages
Category:Implemented
Category:2007
JumpFuck

Brainfuck, but with some differences:
* Unbounded cell size. (already done by many BF interpreters)
* Automatically expanding tape. (ditto)
* An extra block of memory (also automatically expanding) containing jump points.
* Two extra commands:
& Replace the jump point whose ID is in the current cell with the current jump point, and
 change the current cell to 0 if we come from & or the argument if we come from %.
% Jump to the point whose ID is in the current cell, using the next cell as an argument.
This makes it far easier to compile to.
== Examples ==
=== Infinite loop ===
(Admittedly, you don't actually need jump points to do this.)
+&>+++++++.<[-]+%
==Implementations==
weave.rb interprets JumpFuck with the -j flag.
Category:Languages
Category:Turing complete
Category:Brainfuck derivatives
Category:Implemented
Category:2007
Jumpback

Jumpback is an esoteric programming language with no forward jumps.
== Instructions ==
MOV dst, src			Copy src to dst
ADD dst, src			Add src to dst
SUB dst, src			Subtract src from dst
ADDEQ dst, src, cmp		Add src to dst if src == cmp
ADDNE dst, src, cmp		Add src to dst if src != cmp
SUBEQ dst, src, cmp		Subtract src from dst if src == cmp
SUBNE dst, src, cmp		Subtract src from dst if src != cmp
NEG dst				dst = (-1) * dst
PSH src				Push src to value stack
POP dst				Pop to dst from value stack
LBL				Push IP to address stack
JEQ a, b			Jump if a == b
JNE a, b			Jump if a != b
JLE a, b			Jump if a < b
JGE a, b			Jump if a > g
SHOW a				Display a
Jumps pop the target from the address stack.
== Addressing modes ==
$ - Immediate
# - Memory
@ - Memory indirect
i.e.
MOV #0, 1		Writes the number 1 to memory[0]
MOV #0, #1		memory[0] = memory[1]
MOV #0, @1		memory[0] = memory[memory[1]]
MOV @0, @1		memory[memory[0]] = memory[memory[1]]
== Examples ==
MOV #0, 10
MOV #1, 0
LBL
SHOW #0
SUB #0, 1
JNE #0, #1
is a countdown from 10 to 0.
The following program prints the first ten Fibonacci numbers:
 MOV #0, 0
 MOV #1, 1
 MOV #2, 2
 SHOW #0
 SHOW #1
 LBL
 PSH #1
 ADD #1, #0
 POP #0
 SHOW #1
 ADD #2, 1
 JNE #2, 10
==Interpreter==
* Common Lisp implementation of the Jumpback programming language.
Category:Languages
Category:Implemented
Category:2015
Jumper

Jumper is an assembly-like language made by Somnium for codegolf.
== RAM ==
Jumper is a lot like Brainfuck, though the tape is called RAM and it has some different properties:
* It operates with random-access-memory with bytes as cells. RAM is zero indexed and initially filled with zeros.
* When trying access cells with negative indexes error should be displayed and program terminated.
* When trying read at larger index than last, zero should be returned.
* When trying write at larger index than last, RAM should be increased to multiple of 1024 and new cells filled with zeros (technically you can increase RAM not to multiple of 1024, reason was performance boost, so if it costs you a lot of characters you can do it not to multiple of 1024).
Program also has pointer to cell in RAM which initially is zero
* When program starts executing a prompt for input string should be displayed (or take input from command line arguments, it's up to you). Input string should not contain null character (zero byte). Then input string is written to RAM starting at zero index.
* When program ends executing a box with program output is displayed - contents of RAM from zero index to first zero byte excluding.
== Commands ==
Jumper consists of commands (unary operators-prefixes) and their arguments. Commands and arguments may be delimited with spaces or new lines but not necessary. However spaces inside arguments are invalid, for example, # 2 = 4 is valid, but # 2 = 4 4 is not.
Programs can have comments between (). Comments can't be nested - for example, in (abc(def)ghi) comment is (abc(def). Comments can be placed anywhere.
* #123 sets RAM pointer to 123 (any positive decimal integer or zero).
* >123 increments RAM pointer by 123 (any positive decimal integer).
* <123 decrements RAM pointer by 123 (any positive decimal integer).
* =123 writes 123 (any unsigned 8-bit decimal integer) in current cell.
* +123 adds 123 (any unsigned 8-bit decimal integer) to current cell (modulo 256).
* -123 subtracts 123 (any unsigned 8-bit decimal integer) from current cell (modulo 256).
* :123 - “goto” - goes to command number 123 (first is 0). You can control flow of your program only with goto’s - it has to jump - that’s why this language is called Jumper.
If argument is missing, it is 1 for ><+- commands or 0 for #=: commands.
Also, there is command modifier - ? (prefix to command), it executes next command only if current cell is not zero, else skips that command. Can be applied to any command. 
For example, `?:17` - goes to command 17 if current cell is not zero.
== Examples ==
 (prints "Hello world!" regardless of input)
 =72>=101>=108>=108>=111>=32>=119>=111>=114>=108>=100>=33>=
 (appends "!" to the end of input string)
 ?:2 :4 >1 :0 =33 >1 =0
== External resources ==
* Original specification
Category:Languages
Category:2014
Category:Golfing language
Jumping True

Jumping True is an esolang created by MathR. Its main particularity is that its conditional statement is based on the truth-machine. It also has jumps, hence its name.
==Language overview==
In Jumping True there are 9 variables, named from a to i. They can be only true or false. To change the content of a variable you can use:
 change [variable name]
If the variable is true then it will be false and if it's false it will be true.
You can ask for a value to be put in the variable:
 input [variable name]
To display it you can use:
 print [value]
where value can be a variable, true or false.
The conditional statement is
 truth [value]
If value is true, then doing a
 return
will jump back to it.
You can also do a
 jump [somewhere]
which will jump to line somewhere if it's a number or jump to the first
 mark [name]
found if somewhere is the name. One jump can only be used one time in an execution, except if the command
 resetjumps
is executed. It will "reactivate" all the jumps.
There's also an
 ascii [1] [2] [3] [4] [5] [6] [7] [8]
command to display a character with 1|2|3|4|5|6|7|8 the ascii code of the character.
There's a pointer which can be incremented with
 incptr
and decremented with
 decptr
To read and change the pointed value use ptd like a variable name.
==Examples==
===Hello World===
 ascii 0 1 0 0 1 0 0 0
 ascii 0 1 1 0 0 1 0 1
 ascii 0 1 1 0 1 1 0 0
 ascii 0 1 1 0 1 1 0 0
 ascii 0 1 1 0 1 1 1 1
 ascii 0 0 1 0 0 0 0 0
 ascii 0 1 1 1 0 1 1 1
 ascii 0 1 1 0 1 1 1 1
 ascii 0 1 1 1 0 0 1 0
 ascii 0 1 1 0 1 1 0 0
 ascii 0 1 1 0 0 1 0 0
 ascii 0 0 1 0 0 0 0 1
 ascii 0 0 0 0 1 0 1 0
===Truth-machine===
 input a
 truth a
 print a
 return
===If-else===
Print the second registered value if the first is true, the third otherwise.
 input a
 input b
 input c
 truth true
 jump start_if
 print c
 jump end
 mark start_if
 truth a
 jump return_if
 print b
 jump end
 mark return_if
 return
 mark end
==External resources==
Python interpreter: https://github.com/theMathR/Jumping-True
Category:LanguagesCategory:2021Category:Implemented
Jumping to -1 is exciting

A tape-based language whose informal name and acronym is "wapr". The name is a pun on the first line of the original spec - being that "Jumping to -1 is exiting." - this still holds true.
! f t c -> jump (t if c else f)
" x -> -x
# ... n2 n1 n0 2 1 -> ... n1 n2 n0
# ... n2 n1 n0 1 -1 -> ... n2 n0
$ x y -> x+y
% x -> x x
anything else (apart from whitespace) append to tape (% 127) - 38
blahbot` in #esoteric can run this.
Category:Languages Category:Implemented Category:Cell-based
Jumplang

Jumplang is a brainfuck-derived esolang by User:PythonshellDebugwindow designed to be easier to implement in another esolang than normal brainfuck.
== Commands ==
A list of commands and what they do in Jumplang are listed here. To see the differences between brainfuck and Jumplang see “Differences from brainfuck”.
Jumplang Command	Description
+ 	Increment the current cell by 1
- 	Decrement the current cell by 1
> 	Increment the cell pointer
< 	Decrement the cell pointer
, 	Input an ASCII character to the current cell
. 	Output the current cell as an ASCII character
^ 	Increment the current cell by 2
v 	Decrement the current cell by 2
? 	Skips the next command if the current cell is 0
! 	Performs an absolute jump to the 0-based Nth character in the source, where N is the cell pointer + 1th cell (jumping negative or out of bounds halts the program)
All others are nops.
==Differences from brainfuck==
Jumplang has most of the same commands as brainfuck, but it adds two new commands: ^, which increments the current cell twice, and v, which decrements the current cell twice. While it removes the looping commands, it adds the ? conditional skip command which skips the next command if the current cell is zero and the ! command, which jumps to the 0-based Nth command where N is the cell pointer + 1th cell (jumping <0 or out-of-bounds = halt). This requires interpreters to use at least right-unbounded integers for the cells.
==Turing-completeness==
Turing-complete by translation from brainfuck with zero loops (loop on 0 instead of nonzero). See talk page for details.
==Minimization==
See Jumpmin.
==Examples==
=== Cat ===
 ,?.?!>-<!
==See also==
* Jumpmin, a minimalization of Jumplang
* GotoFuck
== External resources ==
Interpreter
Category:Languages Category:2020 Category:Brainfuck derivatives Category:Turing complete Category:Low-level Category:Implemented
Jumpmin

Jumpmin is a minimalized version of Jumplang created by User:PythonshellDebugwindow. The goal of this language is to remain a Turing-complete simple translation of Jumplang.
==The original commands==
We start with a hefty 10 commands, so a minimalization will be welcome among avid Jumplangers.
Jumplang Command	Description
+ 	Increment the current cell by 1
- 	Decrement the current cell by 1
> 	Increment the cell pointer
< 	Decrement the cell pointer
, 	Input an ASCII character to the current cell
. 	Output the current cell as an ASCII character
^ 	Increment the current cell by 2
v 	Decrement the current cell by 2
? 	Skips the next command if the current cell is 0
! 	Performs an absolute jump to the 0-based Nth character in the source, where N is the cell pointer + 1th cell (jumping negative or out of bounds halts the program)
All others are nops.
==Minimalization==
Our 10 instructions include I/O (, and .), which is unnecessary for Turing-completeness, so it can be removed, leaving 8 instructions. The ^ and v can now be used for all your incrementing and decrementing needs (their only real advantages over + and - were I/O-related—they were good for printing characters with odd ASCII values and for zeroing characters with odd ASCII values—but since I/O is now removed, they have no advantage over the increment-by-2 and decrement-by-2 commands), so + and - can be removed. We now have 6 instructions:
Intermediate Command	Description
> 	Increment the cell pointer
< 	Decrement the cell pointer
^ 	Increment the current cell by 2
v 	Decrement the current cell by 2
? 	Skips the next command if the current cell is 0
! 	Performs an absolute jump to the 0-based Nth character in the source, where N is the cell pointer + 1th cell (jumping negative or out of bounds halts the program)
?! can be merged into one instruction, ‽, which is a conditional jump (the current cell is used for the condition, and the cell after that is used for the jump address), leaving us with a 5-command Turing-complete Jumplang minimalization.
==Minimized commands==
Minimalized Command	Description
> 	Increment the cell pointer
< 	Decrement the cell pointer
^ 	Increment the current cell by 2
v 	Decrement the current cell by 2
‽ 	If the current cell is 0, performs an absolute jump to the 0-based Nth character in the source, where N is the cell pointer + 1th cell (jumping negative or out of bounds halts the program)
==Simple translation to Jumplang==
Jumpmin	Jumplang
> 	></code>
< 	<</code>
^ 	^</code>
v 	v</code>
‽ 	?!</code>
As you can see, not much has changed (except, of course, the 4 completely removed commands).
==Translator to Jumplang==
 def jumpmin_to_jumplang(jm):
 jl = ""
 for c in jm:
 if c == "‽": jl += "?!"
 else: jl += c
 return jl
==Further development==
If you have any ideas of how to further minimize the language while keeping it TC, you can put them on the talk page.
Category:Languages Category:2020 Category:Brainfuck derivatives Category:Turing complete Category:Low-level Category:Implemented
Jumpy

Jumpy is an esoteric programming language.
==Syntax==
A Jumpy program consists of a series of lines of code, and on each line there is a single number. 
==Execution==
Conceptually, the lines are numbered from 0 upwards. Execution starts at 0, and proceeds in a series of steps. At each step, the interpreter finds the line of code that matches the number, and transitions to the number found on that line. The interpreter outputs to the console the beginning and ending numbers for that transition, separated by '->'. If the ending line number does not exist, then the program terminates.
==Example Program==
===Program===
 1
 3
 2
 4
===Output===
 0 -> 1
 1 -> 3
 3 -> 4
==Program Size==
In a Jumpy program, the number of lines of code, and the size of the integers represented on each line are both theoretically infinite. In practise, a program running on a computer will limit both of these due to limits in available memory and integer representation.
==Turing Completeness==
Jumpy is Turing Complete. To see why, consider its relationship to Game of Life. Game of Life has been proven Turing Complete. We can construct a mapping from a Game of Life program to a Jumpy program as follows. First we develop an encoding for the cells of empty the Game of Life board. We can number these by following a spiral path from the origin in ever increasing squares, until a square bounding box of any size is reached. We assign a single bit to each of these cell-numbers. Let's say this gives us N bits. The binary numbers up to 2^N can be mapped to the Game of Life configurations where each bit represents a cell (0 if dead, and 1 if alive). Next we identify the transition state for each of these states, forming a transition table, and this forms the main part of our Jumpy program. Lastly, we identify the beginning state of our Game of Life program, and place that as line 0 in our Jumpy program.
Category:Languages Category:2024 Category:Low-level Category:Output only Category:Turing complete Category:Turing tarpits
Juna

Juna is a esolang based on NAND logic. It uses a list of registers (one for each non-negative integer), each of which can store one bit and starts set to 0. Every line number is also a non-negative integer. Jumping to . halts the program. Execution starts on line 0.
==Syntax==
Each line is 5 commands long and are in one of the following forms:
 L a b Y N
* Line L: set register b to register a NAND b. If register b = 0, jump to line Y, else jump to line N
 L . b Y N
* Line L: set register b to input. If register b = 0, jump to line Y, else jump to line N
 L a . Y N
* Line L: output register a. If register a = 0, jump to line Y, else jump to line N
# starts a comment that goes to the end of the line.
==Examples==
Example program: Truth-machine
 0 . 0 1 2 #Set register 0 to inputted value. If it's 0, jump to line 1, else jump to line 2
 1 0 . . . #Print register 0 (value 0), then halt
 2 0 . 2 2 #Print register 0 (value 1), then repeat
Example program 2: "Hi" in binary (Hello, world! is too long :/)
 0 1 1 1 1 #Set register 1 to 0 NAND 0 (1)
 1 0 . 2 2 #Printing
 2 1 . 3 3
 3 0 . 4 4
 4 0 . 5 5
 5 1 . 6 6
 6 0 . 7 7
 7 0 . 8 8
 8 0 . 9 9
 9 0 . 10 10
 10 1 . 11 11
 11 1 . 12 12
 12 0 . 13 13
 13 1 . 14 14
 14 0 . 15 15
 15 0 . 16 16
 16 1 . . .
==Interpreter==
* Common Lisp implementation of the Juna programming language.
Category:Languages Category:Unknown computational class