> Just so we're talking about the same thing, I think Daniel is
> saying:
> Magic: Unwritten functionality
Well, I was actually thinking about my usage of this term recently
due to another context. Usually, I seem to mean something where
somebody had to stare at the system the right way and have the right
knowledge in hand to say "tweak here, here, and here, and it will
behave better". The thing I was thinking of was TCP congestion
control: the algorithms involved are simple enough to describe, but
there is interesting emergent behavior when you put a bunch of them
together. Van Jacobson et al's work here is what I would call
"magic", even though it exists in a reified executable form.
> Oracle: Authoritative source
Eh, don't know that I like this one. The overall structural
description of a few days works better for me, but doesn't have a two
word label other than "oracle function", and we don't like that.
More expansively, "the oracle" is really a small semantic
processing tool coupled with semantics for many, many systems small
and large (these semantics being written by us). The tool enables
composing semantic information together in different ways for
reasoning purposes towards asking questions like "configuration" and
more generally "meaning": if I emit the utterance "no router bgp" to a
particular router in my network, just what is the effect on the world?
If I wanted to perform the "rollback" operation after speaking such a
statement with minimal effect, what must I really say, and what am I
really asking for anyway?
When you have semantic tools, meaning is just another expressible
thing, typically in the form of a function value of some sort; the
domain and range of the function value are specific to the realm of
the semantic.
In programming language semantics, the domain and range often
relate to the state of a very abstract machine -- this sort of thing
produces the ability to reason with the meaning of side effects, for
example. Our worlds are larger.
> The thing that makes it hard to get at what he's saying is that
> he's mixing the language of mathematics and mysticism :). I don't always
> understand him either (due to lack of time :) ) but the bits I understand
> seem right.
You say mathematics, I say tomato. You say mysticism, I say
tomato. :)
I can't speak for your lack of time, but I can speak for my poor
use of the nominal language of discourse. I shall continue towards
that nebulous halfway point.
I will mostly try to avoid the issues that reek of myticsm to you.
But they aren't *entirely* seperable you see unless you are careful
with your engineering. Network configuration can probably avoid these
issues readily, but some of the configuration spaces I've shown up in
have created some interesting edge cases...
The edge cases that reek of mysticm are the interesting ones to
use to break a model. Pick an absolutely ridiculous infinity point
for your model, and see what happens when you try to express this
fairly infinite concept in it. What does it look like? Is it clumsy?
Does the model completely fall apart in some way?
Let me synthesize an example based on some of Juergen's objections
about side effects and rollback.
Remember how I said the other day that treatment of side effects
is "perfectly doable", and cited the denotational semantic of scheme
embedded in R5RS as an example?
Well, it's not *entirely* truthful, because "side effect" can be
more or less complicated depending on precisely what we said, and its
context. The semantic for scheme presents meaning functions for side
effects within the world of scheme. Side effects crossing the world
of scheme into the broader world are your problem.
Side effects within the world of scheme that are expressed are
things like "what does '(set! foo 25)' mean?".
Side effects crossing from scheme to the broader world that are
not expressed in the semantic would include statements like:
what does
(begin (display "what time is it?") (newline))
mean?
The reason why such a case isn't handled is that it's "just a
little bit harder" than the case of in language side-effects.
One way of shedding more light on the difference between the two
is the degree of closure we can provide over the two, and our ability
to observe the side effect.
Side effects that happen "within scheme" are fairly "closable" --
we can write down a world of "scheme interpreter" mathematically (as
the semantic of scheme does) and show what the side effect means soley
within the context of that world readily. But these side effects
can't be observed from outside the world of scheme.
Side effects crossing from scheme to the broader world have
closure problems: you have to define what the broader world is in
order to define a meaning function for the side effect. As far as
visibility goes, naturally the point of such a side effect is to
provide a window of observation from our broader world into realms
like our scheme interpreter.
Definining this broader world can get dangerous if we aren't
careful: I suppose you could call it mysticsm past a point, or asking
annoying theological questions, or any number of things.
To give you some idea of what you can do if you aren't careful,
consider the scheme program "(begin ..." from above again.
I can run this program and insert its output in the next line:
what time is it?
as I have done above.
Consider the program output for a moment, and reconsider the
question of:
what does (begin (display "what time is it?") (newline)) mean?
given that you, dear reader, have been specified as a part of this
system. You are human, and any and all responses any and all of you
could possibly imagine to make this meaning function as uncomputable
as possible are fair game.
I will assert that infinity is a good tool for abusing your
models.
Anyway, we seem to be drifting a little bit, other than the fact
that having such extreme examples of "here are questions not to ask"
written down is useful. Where are we on "specification,
specification, specification?"
I've heard:
* The usual semantic/knowledge representation problems.
* You want a rollback operator in the resultant calculus to hang
arbitrarily complicated rollback functions from.
* Very distributed realization to provide proper robustness
properties, etc.
Follow-Ups:
References:
|
|
