> We deal differently with atime, mtime, ctime than local filesystems
> for efficiency. Due to replication of volumes we carry a lot of
> stuff around that is used internally: so called version vectors
> count the number of updates at each replication server, to keep
> replicas in sync.

That statement sounds very familiar; I could almost have said it about
WVfs.  I have a run-length-encoded representation for the dot-dot link
so I can share parent directories between version sets.  In this
representation there are 31 possible permutations, which fold into 21
cases I identify, which fold into 6 actions I do.  Regression tests
written at the same time as the code (write a test, write a feature)
are the only thing that save my sanity.

Peter, do you use any programmatic means in Coda to increase
programmer leverage?  Some examples might be:

	marshaling C structs to variable-length lists on disk and back

	little scripts that generate all possible permutations of data
	structure a in code, so none are missed

	good regression test interfaces (small programs that unit
	tests routines, scripts in internal languages to preload
	state, gdb scripts to tweak a running system); scripts that
	generate regression test vectors

	algebraic transformations of code (factor out common
	routines), or data (modify access routines to match new
	schema).  given all schemas and all queries, it should be
	possible to normalize and denormalize the schema interactively
	in a graph browser while transforming the queries to return
	the same results.

	timing diagrams or state machines to design or enforce
	sequencing; programmer-invisible locking of data structures to
	enforce consistency; threads; deadlock detection and
	constraint checking on the graph of all sequencing transitions
	(aka Unix version 10 "spin" program, and what ML users tend to do)

	run-time profiling that configures the algorithm selection
	(sort on insert vs. sort on report)

	graph-based graphical interactive editors that let programmers
	scribble code on a whiteboard as it comes to them, then
	assemble the pieces of the jigsaw puzzle


Or do you mostly use the design method of "draw it on a whiteboard and
stare at it a lot"?  Sometimes I think the EE chip designer/silicon
compiler/test vector generation/design for testing/boundry scan/
simulation/finite element analysis people are doing all the real CS
work today.  Have you seen what their tools can do?  Enter a set of
logic equations and output a netlist of gates optimized for speed, or
space, or anywhere in between at the control of a knob?  The
difference in output structure goes way beyond what a -O flag does on
gcc.  Yes, I know the introduction of meaningful amounts of state
makes the theory supporting this method explode computationally.  But
I'm not convinced the existing tools wouldn't be useful to me, and I'm
not convinced there isn't better theory waiting to be discovered.


Another member of the League for Programming Freedom (LPF) www.lpf.org
-------------------------------------------------------------------------------
Brian Bartholomew - bb_at_wv.com - www.wv.com - Working Version, Cambridge, MA