For each new line, use indent for stack depth, and can put var names at each level to name what is there. Can still use long lines.  e.g.:

	1 2
	a	b	+
	c	?
3


For virtual variables / properties...  use syntax like:
		get o
instead of:
		o @

get stores a message code on the stack, o pops it and calls the appropriate
function for object 'o'.

To refer to something instead of calling it, use ref:
		ref o
that could be a message that is sent to o too,
or it could be a word that "reads ahead" in the program (has an arg in the
program as opposed to on the stack).


Not sure if my foo <foo >foo !foo \foo stuff is any good, doesn't support
virtual properties.  But I guess we need some low level peek/poke or storage
too.

jitfroth -> fast


future CZ syntax for OO:

		target: message args
or
		target, message args

->

		target_type__message(target, args)

or just:
		message args
 to talk to itself or the context, auto resolve

accessing properties:
		target:property
		target:property.subprop

Use trailing ? for functions, and maybe varname:
		s = vec, size?
		vec, size? s
		

scripting:  instead of describing how a process works within one object,
describe the sequences of actions / messages between several objects, like a
play script / protocol.
  fred: joe, cook food
  joe: fred, what food?