Write README

README.md

@@ -0,0 +1,39 @@
+# Flip
+
+Flip is a single-instruction Turing-complete programming language.
+
+Let me break that down for you:
+
+- Turing-complete means that Flip can do basically anything given enough time and memory. Anything!
+
+- Single-instruction means that Flip only has one instruction. WTF, one instruction?
+
+Flip uses a single 2-by-infinity array of bits for memory. That's all the memory you get, sorry.
+
+The only instruction is `flip(x, y)` where `x` is 0 or 1 and `y` is an integer. This flips the bit at index `(x, y)` in the array and returns the flipped value. You can nest `flip(x, y)`, but only for the first parameter. So, `flip(flip(flip(a, b), c), d)` is valid while `flip(flip(a, b), flip(c, d))` is not.
+
+You'll probably get tired writing `flip` and parentheses all day, so [unlike in Lisp](https://xkcd.com/297/), you can throw out all the parentheses and `flip` instructions. Thus, Flip programs look like this:
+```
+0 0
+0 1
+0 0 2
+0 2 1 3
+0 3
+```
+
+That means the same thing as
+```
+flip(0, 0)
+flip(0, 1)
+flip(flip(0, 0), 2)
+flip(flip(flip(0, 2), 1), 3)
+flip(0, 3)
+```
+
+We think you'll agree that the first version is way more aesthetically pleasing and forgiving for your pinky finger.
+
+If you haven't figured it out yet, the Flip program above is [NAND](https://en.wikipedia.org/wiki/NAND_logic#Making_other_gates_by_using_NAND_gates)! Currently, the final line outputs 0, but remove either of the first two lines, and the final output becomes 1. This makes Flip (drumroll please)... Turing complete!
+
+Even better, a Flip interpreter can be trivially implemented in your favorite programming language. See [Flipper](flipper.py) for the official reference implementation written in Python.
+
+So if you're ever feeling down about how horrible today's modern programming languages are, try writing some Flip to flip your day around!

nand.f

@@ -1,4 +1,5 @@
 0 0
+0 1
 0 0 2
 0 2 1 3
 0 3

test.f

@@ -1,4 +0,0 @@
-0 0
-0 0
-0 0
-0 0