Hello All,

More than once I speculated why Coda hardly ever experienced active
contributions from the community. For a long time my best guess
was that the threshold to understanding of distributed systems
is too high - because of this Coda must be especially hard.

Now I am quite convinced that this is not a correct explanation.

The main obstacle for contributions is IMO nothing else than confusion.

It is in fact very hard to distinguish the vital concepts when they
are covered (in thick layers) by obscure implementation choices.

Don't misinterpret me - Coda is brilliant conceptually and has many
really clever implementation pieces.

Nevertheless, too little care can be seen in the code and in the
documentation to put a distinctive line between what belongs to the
concept and what is a rather arbitrary choice, or/and to make it easy
to follow the logic. (For the researchers in the field it was much less
of an issue, though I suspect even they were sometimes mislead)

As an example, a naming pattern suitable for an academic paper is
hardly practical for a newcomer.

 ...
    repvol_iterator rnext;
    volrep_iterator vnext;
 ...

Quite easy to perceive which refers to what? I do not think so.
At least yours truly becomes frustrated while reading such pieces,
am I the only one?

A simple rename of the related variables to use e.g. "instance" instead
of "replica" (if keeping the wording "replicated volume") would provide
a remarkable relief.

As another example, the confusion in the pretty simple case of
ReplaceRootServers() would hardly happen if the author would not have
applied extra bells and whistles of C++, for no benefit.

My point is:

We can contribute much to Coda's future by changes which may be pointless
(or even slightly negative) technically but which make the code and the
deployment model easier to follow and understand.

Without bells and whistles our train will go faster and will be much
more comfortable to take. This is otherwise well known as KISS.

So the most valuable steps are probably not the move from VLS to DNS or
replacing the Needham-and Schroeder handshake but rather

 straightforward simplification and restructuring.

Does this make sense to you?

Looking forward to the coming new git repository - which is also a step
to making contributions easier and hence more feasible.

Rune