I don’t quite get it; or rather, I disagree with most of it:
Am 22.01.22 um 14:07 schrieb Raul Miller:
This difference could be prevented by preventing names from being
updated. And, languages have been implemented with that characteristic
(for example, Haskell). (And, of course, quite a lot of work has
gone into bringing re-implementing having names refer to sequentially
new values in Haskell.)
But also, that kind of change (making name assignments "permanent")
would break quite a lot of existing code, which was written in J.
You're well on your way to specifying a different language if you
want to change this characteristic.
What is a language? As a set of accepted words over some alphabet,
it may remain the same, but semantics is part of the language, too.
So each new version is another language, and this is no exception.
That being said, I doubt that the change you have in mind was
intended by Elijah.
No, I don’t think he wants to change this characteristic.
But he pointed it out, and the matter of fact it may not be
adequately documented.
As for the rank issue, that was described (albeit in a formal fashion)
in the dictionary.https://www.jsoftware.com/help/dictionary/dict3.htm
gives an overview, and rank is described in further detail in various
parts of the dictionary.
That is true, but it does not change the fact that the dictionary claims
that 'x u&v y ↔ (v x) u (v y)', and that that is not correct.
I disagree.
That said, if your concept of ↔ does not allow for machine constraints,
and requires non-contextual understanding of definitions, I can see
how you would reach that conclusion.
I do agree.
Equivalence is an abstract rigorous notion, not to be confused
with the everyday (not the geometrical) “similarity” term.
And there is a distinction to be made between syntax and semantics.
That’s why we need soundness and completeness theorems in logic.
Eg, x u&v y could actually made to be equivalent to (v x) u (v y)
even though it currently isn’t. But I didn’t read anyone proposing this.
A syntax doesn’t constrain you to any specific semantic interpretation.
Conversely, any semantic specifics (machine constraints) cannot possibly
be expressed in terms of syntax.
(Among the bad things about “readable” C style syntax:
people believe they don’t need to learn the semantics
because words are used they know from everyday language
and they think there’s a semantical 1:1 translation.)
Language standards are indeed formal statements, but they cannot be
entirely independent of the machine implementation(s).
I disagree. Standards may be_informed_ by implementations (or, more to
the point, implementation concerns), but they exist independently of them.
Case in point: the dictionary does not give an evaluation order for fork,
but JE does.
How is this a disagreement? (It seems to me that a standard which
is informed by an implementation is necessarily not completely
independent of that implementation.)
Wrong. Informed by an implementation means: this is a cooperative
thing so there’s no point in mixing random syntax and semantics.
The more the syntax “reflects” actually implemented semantics in
some way, the less its writers will have to translate their thoughts
(semantics, significate) into program prose (syntax, significand).
And if I want some kinds of semantics, I need to provide at least
some ways of expressing this, which must be different from each other.
More precisely, the mapping from syntactically correct programs
to semantic execution a language means to provide must be surjective.
(But not injective, cf “equivalence” above, syntactic sugar etc)
But a language may choose to not constrain some parts of execution,
eg order of evaluation, in which case it doesn’t need to provide
(but nonetheless may still provide) different syntactical forms.
Here, some relevant abstractions include:
(1) functional vs. machine state semantics
(2) parallel vs. serial implementation
I do not see the significance of these. The machine is not 'special'; it
is simply another set of semantics. We express one set of semantics in
terms of another; that is what compilation means.
The machine is special because it implements the semantics.
Compilation /does not/ merely express one set of semantics in terms
of another. There are no more semantics in program code than oxygen
molecules in oxymorons. And machine code is no different.
They are, if the compiler is correct wrt the language definition,
equivalent syntaxes for the same (not necessarily intended) semantics
in two languages (we call these translations of one another).
(3) current vs. future versions
A future implementation version may implement a different language. Which
must be specified differently, but there is no problem with that.
You might be underestimating the problems involved in implenting a
different language.
That’s not what he’s talking about.
Once you /have/ different implementations,
they define different languages. Then that
language must, if we want to, be specified
differently. No problem.
You perverted the order and said we first
have a new formal language definition and
then need to implement it.
--
----------------------
mail written using NEO
neo-layout.org
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
