Code as a repository of knowledge

I added the "code is a repository of knowledge, but it's impossible to get that knowledge back out" theme to my ever growing collection of soap boxes a while ago. I've just come across the thought in a rather different context.

Even though code makes for a description of solutions in a fairly objective language, the bottom line is that it makes for a poor repository of knowledge when that language becomes an endangered species. [Lambda the Ultimate]

It's good to see the idea crop up, but this presentation only goes part of the way. Chris seems to be of the opinion that the problem would be solved if we could translate code written in an "endangered" language (Common Lisp to Dylan would seem to be translating from the less to the more endangered language, but that's not the point).

Language translation efforts seem to rarely succeed. I've had a few successes here and there, but an intense familiarity with both languages as well as the software is required. [Lambda the Ultimate]

I'm not convinced. In the case of models of environmental processes, for example, a huge amount of knowledge is embedded in software implementations of those models, and reading the code is more or less the only way of getting hold of that knowledge. Descriptions of models tend to be ambiguous or incomplete, and they rarely describe in detail the implementation of the model as actual, running, code. The process of translating a mathematical model into a numerical one, and on to functioning code, generally results in code which completely masks the structure of the model.

Code is a dreadful knowledge representation format, not just because a language dying out leaves you with no way to make use of the thus represented knowledge, but because there is no good way to recover the knowledge from its representation back into a human brain where it can do some good.

This is why I find syntactic abstraction exciting. It is also why I think that using Communicating Sequential Processes has real potential as a software structuring technique for models; isolate the sequential bits, and then describe the composition in declarative terms.