Backhand

Backhand is an esoteric programming language created by User:Jo King which is a 1D stack based language inspired by 2D languages like ><> and Befunge. The name comes from the phrase "Back and Forth", which describes the way the instruction pointer travels.
== Concepts ==
Backhand operates on a 1D tape of instructions, but crucially it does not execute these sequentially. Instead, the instruction pointer moves multiple steps at a time, initially starting at the first instruction, and moving in steps of 3. For example, the program:
 1 1 + O @
will skip all the spaces between instructions and only executes 11+O@ (which simply adds 1 to 1 and outputs the result). When the instruction is about to step out of bounds of the program, it instead reverses direction and moves the other way. For example, the above program can be shortened to 1O+1@, which executes as below.
 1..1. Bounce off end and go left
 ..+.. Bounce off start and go right
 .O..@ End
It's easy to confirm this by counting the number of dots between each instruction, which should be 2 (ends are only counted once)
This can lead to compressed programs folding in on themselves, such as "ol!,ld elWHro", which prints "Hello, World!". You can also decrease and increase this step counter itself, using instructions like ^ or M to increase it, or v and W to decrease it. Note that if you decrease the step counter below zero than directionals like < or > will have the opposite effect.
== Data structure ==
Similar to Brain-Flak, Backhand uses two separate stacks of numbers. You usually operate on the main stack, but you can push/pull to the other stack with ( and ) respectively, or even swap the two stacks with x. Attempting to pop from an empty stack will yield 0 instead. Backhand also has a register, which can store one value to be retrieved later (both with the & instruction).
== Input/Output ==
Input can be read with the i and I instructions, which reads characters and numbers respectively. The i instruction pushes the ordinal value of the next character of input, and I ignores input until it reaches a number (which can include a negative sign before it). For both instructions, if no more input is available they push -1 to the stack.
There are also the associated output instructions o and O which output as characters and numbers respectively.
== Errors ==
Errors are caused by:
* Division by zero
* An empty program
* Trying to print a value out of the range of 0 to 0x10FFFF
== Instructions ==
Any character that is not an instruction is a no-op and does nothing.
=== Literals ===
Character(s)	Name 	Action
0-9a-f 	Number 	Pushs the appropriate number. The characters a to f push the values 10 to 15
" 	String 	Turn on string mode, which pushes the ASCII value of each character until it reaches either another "
' 	Character	Push the ordinal value of the next instruction instead of executing it
=== Stack manipulation ===
Character	Name 	Action
~ 	Pop 	Pop and discard a
$ 	Swap 	Pop a then b and push a then b
: 	Dupe 	Pop a then push a twice
& 	Register	If there is not a value in the register, pop a and store a in the register. Otherwise, push the value in the register and clear it
r 	Reverse 	Reverse the stack
l 	Length 	Push the length of the stack
( 	Pull 	Pop a from the other stack and push a
) 	Push 	Pop a and push a to the other stack
x 	Switch 	Swap the main and other stack
=== Control Flow === 
Character	Name 	Action
< 	Left 	Change direction to left
> 	Right 	Change direction to right
{ 	Step Left 	Step left one
} 	Step Right 	Step right one
^ 	Increment Step 	Increase the step value by 1
M 	Double Increment Step	Increase the step value by 2
v 	Decrement Step 	Decrease the step value by 1
W 	Double Decrement Step	Decrease the step value by 2
? 	Random 	Step left or right randomly
j 	Jump 	Pop a and jump to the ath character, bouncing off the sides as usual. 0 represents the first character
s 	Skip 	Pop a and skip forward a characters, bouncing off the sides as usual. This moves forward in the current direction
@ 	Terminate 	End the program
=== Branching ===
Character	Name 	Action
_ 	Decision Step 	Pop a and if a is zero step right, else step left
 	Decision Change	Pop a and if a is not zero reverse direction
! 	Not 	Pop a and push 1 if a is equal to 0, otherwise 0
L 	Less 	Pop a then b and push 1 if a is less than b, otherwise 0
G 	Greater 	Pop a then b and push 1 if a is greater than b, otherwise 0
E 	Equal 	Pop a then b and push 1 if a is equal to b, otherwise 0
=== Arithmetic ===
Character	Name 	Action
- 	Subtraction 	Pop two values a then b and push b-a
+ 	Addition 	Pop two values a then b and push b-a
* 	Multiplication	Pop two values a then b and push b*a
/ 	Division 	Pop two values a then b and push b//a, the integer division of b and a
% 	Modulo 	Pop two values a then b and push b%a, where the sign of the result matches the sign of a
[ 	Decrement 	Pop a and push a-1
] 	Increment 	Pop a and push a+1
=== Input/Output ===
Character	Name 	Action
i 	ASCII input 	Push the next byte of input
o 	ASCII output 	Pop a and output a as ASCII
I 	Number input 	Ignore input data until it reaches a number and push that number. If the number is preceeded by a - then the number is negative.
O 	Number output	Pop a and print a as a number
\n 	Newline 	Print a newline
H 	Halt 	Print the contents of the stack as a string and terminate the program
h 	Finish 	Output the top of stack as a number and terminate the program
== Example Programs ==
=== Cat program ===
Terminates with an error:
 io
Or terminating safely:
 {i: o]@|{
=== Hello World! ===
 "ol!,ld elWHro"
=== Factorial ===
 1@ IO :~!{|{}: ([ *).
=== Truth Machine ===
 I|@}: O
=== Quine ===
 "#v{<@^:[ba+0v|{$:o[}
== External Resources ==
* Backhand Interpreter
* https://tio.run/#backhand, an online interpreter
Category:Languages Category:Implemented Category:2018 Category:Stack-based Category:Self-modifying