Isolated

Isolated is a tentative programming language conceived by Tim Stiles in May 2009. It has no stack and no literals, and all four 'variables' are intrinsically related to the programming's functionality; flow is performed by editing the instruction pointer's value relative to something else. I'm not yet sure how useful it is and what the minimum requirements would be to keep it 'in theme' while making it practical; most of it came to me in a 'waking' mental state.
==Language overview==
The programming environment consists of a tape 2^n cells long with n bits in each; arithmetic is two's complement. They all start out equal to 0. The four variables are the tape pointer, the value under the tape pointer, the instruction pointer and 'I/O' which holds the last value taken in and can be used to take in or give out values. (By default I/O is done by the values of characters/unicode depending on tape size)
A program in Isolated is made up of a series of instructions in binary, eight bits long each. One instruction in Isolated is made of two bits (the target), four bits (an operation) and another two bits (the source). Operations are mostly of the form target = target (operator) source. A program does not end if it moves past the last instruction; it is instead taken mod the number of instructions and continues executing until the 'Stop the program' instruction is executed.
==Instructions==
===Variables===
Binary	Description
00 	Tape contents : value under the tape pointer
01 	Tape pointer : points to a cell on the tape
10 	Instruction pointer : useful for flow control; operations are modulo number of instructions
11 	Input/output :
* As the target, output the value assigned; if the target is read (as with +=) the last value from input is used, or 0 if no input has been taken yet.
* As the source, is equal to the next value taken from input.
===Operators===
Binary	Description
0000 	=
0001 	+=
0010 	-=
0011 	*=
0100 	/=
0101 	%=
0110 	AND= (bitwise)
0111 	OR= (bitwise)
1000 	XOR= (bitwise)
1001 	NAND= (bitwise)
1010 	NOR= (bitwise)
1011 	XNOR= (bitwise)
1100 	swap places with
1101 	average (target = (target + source) / 2, or just target / 2 if both are the same)
1110 	
Binary	Description
00 	logical not
01 	arithmetic negation
10 	absolute value
11 	bitwise logical not (this is redundant with target NAND= target)
So, for example:
* 10001000 means ip -= current cell, which moves the program back by the number of instructions under the tape pointer;
* 00000111 means current cell += input, which takes a value from input and adds it to the current tape cell's value
* 11001111 means output *= input, which outputs a character to stdout that is equal to the last character taken from stdin multiplied by a new character to be taken from stdin.
== Tricks ==
* = self is a nop: 00000000, 01000001, 10000010 and 11000011 have no effect.
* += self multiplies target by two.
* average= self divides the target by two.
* NAND= self produces the bitwise inverse.
* -= self resets the target to 0.
* /= self sets the target to 1.
* XNOR= self produces the lowest negative number (all bits 1)
* 11(operator)11 does some operation with the last and next values from input and outputs the result.
== Extended Isolated ==
Extended Isolated intends to fill 16 bit characters instead of 8 bit ones. It has 4 bits for source/target so far:
Binary	Description
0000 	tape contents
0001 	tape pointer
0010 	instruction pointer
0011 	input/output
0100 	last target used
0101 	last source used
0110 	last new value used (read-only)
0111 	instruction pointer delta (number of instructions IP will move after an instruction if IP is not written to; defaults to 1
1000 	instruction under the IP
1001 	tape pointer delta (defaults to 0)
1010 	random number generator (writing to it gives a new seed, reading returns a random number)
1011 	Control (Writing to this would determine how the program is operating; whether it's running or not, how it's processing IO, etc. Probably via a bitmask. Still need to think about this one)
==Example programs==
Note: due to the lack of an interpreter and because the specifications are somewhat ambiguous, the following programs may or may not work.
===Cat program===
Assuming input ends with 0. The 0 is printed as well.
binary Isolated	readable Isolated	pseudo-code
00000011
11000000
00111000
00111000
00000100
00000100
00000100
10001000
10111100	cc = io
 io = cc
 cc unary= lnot
 cc unary= lnot
 cc += cc
 cc += cc
 cc += cc
 ip -= cc
 xx control= stop	take input
 output
 if current cell is 0
 then set it to 0
 else set it to 8
 jump by -8 (loop) or 0 (halt) 
 stop the program
===Truth-machine===
binary Isolated	readable Isolated
00000011
11000000
10000100
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
10111100	cc = io
io = cc
ip += cc
no-op no-op no-op no-op no-op no-op no-op no-op
no-op no-op no-op no-op no-op no-op no-op no-op
no-op no-op no-op no-op no-op no-op no-op no-op
no-op no-op no-op no-op no-op no-op no-op no-op
no-op no-op no-op no-op no-op no-op no-op no-op
no-op no-op no-op no-op no-op no-op no-op no-op
stop
Category:Languages
Category:Cell-based
Category:Non-textual
Category:Unknown computational class
Category:Usability unknown
Category:Unimplemented
Category:2009