README.md in mojikun-1.0.0 vs README.md in mojikun-1.0.1

@@ -2,18 +2,18 @@
 
 A Brainfuck based on Emoji.
 
 Instructions:
 
-👉  Move the pointer to the right
-👈  Move the pointer to the left
-👍  Increment the memory cell under the pointer
-👎  Decrement the memory cell under the pointer
-💻  Output the character signified by the cell at the pointer
-💾  Input a character and store it in the cell at the pointer
-🔃  Jump past the matching 🔙 if the cell under the pointer is 0
-🔙  Jump back to the matching 🔃 if the cell under the pointer is nonzero
+👉  Move the pointer to the right  
+👈  Move the pointer to the left  
+👍  Increment the memory cell under the pointer  
+👎  Decrement the memory cell under the pointer  
+💻  Output the character signified by the cell at the pointer  
+💾  Input a character and store it in the cell at the pointer  
+🔃  Jump past the matching 🔙 if the cell under the pointer is 0  
+🔙  Jump back to the matching 🔃 if the cell under the pointer is nonzero  
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
@@ -31,13 +31,58 @@
 
 A `mojikun` binary is provided to let you run programs. There is an examples
 directory which has some examples. Use `mojikun` like any other interpreter:
 
 ```
-mokikun examples/hello.moji
+mojikun examples/hello.moji
 ```
 
 `.moji` is the preferred file ending for Mojikun.
+
+## Structure
+
+While Mojikun is a simple language that could be interpreted in a 40ish line
+script, I wanted to make it more like a 'real langauge' that would have all
+of the parts and design that a more full one has. I may use this foundation
+later to build more complex things.
+
+We can see these parts in motion by examining the binary:
+
+```ruby
+$ cat bin/mojikun 
+#!/usr/bin/env ruby
+
+require 'mojikun'
+
+source_code = ARGF.read.chomp
+
+tokens = Mojikun::Lexer.new(source_code).call
+
+ast = Mojikun::Parser.new(tokens).call
+
+runtime = Mojikun::Runtime.new
+interpreter = Mojikun::Interpreter.new(runtime)
+
+interpreter.evaluate(ast)
+```
+
+We have a Lexer, Parser, Runtime, and Interpreter. The Lexer turns the stream
+of input into a series of tokens. The Parser takes those tokens and turns them
+into an AST, which is more of a list than a tree, really. We generate a new
+Runtime, which has all of the internal state we need to make the language work:
+the data array, the program counter, etc. Then, the Interpreter takes that
+AST and evaluates it in the context of the Runtime.
+
+Pretty simple!
+
+## Testing
+
+Mojikun is fully tested with MiniTest. I actually wrote it in a TDD fashion.
+To run the tests, simply
+
+```
+$ rake test
+```
 
 ## Contributing
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)