[e-lang] Content Complete, Ready for Comments

David Hopwood david.nospam.hopwood at blueyonder.co.uk
Mon Jun 27 12:22:31 EDT 2005


More comments:

# Progress on the publisher's current plan made the statusHolder aware of the
# need to send this notification, on behalf of some other purpose represented
# by the listener.

"in aid of some other purpose"

# We diagram this pair as an “L” shaped structure.

"diagram" as verb, ick. "In our diagrams we represent this pair..."

# Some OSes [DVH**]

"Some operating system designs..."
(DVH wasn't an implemented OS.)

# Others, by providing principled controls over computational resource
# rights [KeyKOS, EROS, Coyotos**], support full defensive correctness.

Coyotos is not designed yet, so shouldn't be cited in this context.

# A /secure language/ is one which supports some useful form of suspicion
# within a process.

Is this definition too weak?

# thread safe,

thread-safe

# 6.2 POLA

"6.2 Principle of Least Authority"
(the acronym hasn't been defined yet).

# We require that all three vats suspect each other

"are suspicious of each other"
("suspect" tends to imply a belief that a party has done something
specific that is undesirable, rather than that it can't be assumed that
they won't do something undesirable.)

# For example, if we introduced conventional static type checking, this
# might imply more guarantees than can be enforced among mutually suspicious
# machines -- giving programmers a false sense of security, leading them to
# skip cases they needed to consider. (**Clarify or kill this example**)

Kill it. It would be too involved, and too far outside the scope of the paper,
to give an accurate account of what can and can't be enforced by static type
checking. For example, "conventional static type checking" would need to be
distinguished from types enforced by protocol checkers.

# We visualize an unresolved reference as an arrow

We can visualize

# var flag := null
# def epimenides() { return flag <- not() }
# flag := epimenides <- run()

Should this be

   def flag
   def epimenides() { return flag <- not() }
   bind flag := epimenides <- run()

? The code using 'var flag' immediately throws a null reference exception;
this is not a datalock bug, because 'flag' is already bound in the call to
"flag <- not()".

I realise that the paper hasn't otherwise had to introduce 'bind' or explain
that 'def' creates single-assignment variables, but I don't think this
example really works with 'var'.

# Although we have some speculations, on the whole we are at a loss to
# explain the magnitude of this effect.

Out of curiosity, what are your speculations?

# Vulcan was built on a concurrent logic base, and inherited from this base
# some problems absent from pure Actors languages.

Which problems? No need to go into detail, but "some problems" just sounds
mysterious.

Ka-Ping Yee wrote:
 > - JAVA
 > + Java
 >
 >     Remove the small-caps formatting from all the names of programming
 >     languages in this paper; it's jarring and anachronistic.

Hmm, maybe it is, but I do prefer the names in a different font.
Try \sl instead of \sc in the \sys macro.

-- 
David Hopwood <david.nospam.hopwood at blueyonder.co.uk>





More information about the e-lang mailing list