Tunes! and HLL! (fwd)

[Fare Rideau]

Here is a reply I made to a message I just received.
As the reply tells,  I've just added a few things to
the Interfaces subproject [in case you care].

------>8------>8------>8------>8------>8------>8------>8------>8------>8------
To: anon-14195@anon.twwells.com (bytor)
In-Reply-To: <337C156A.3FD@anon.twwells.com> from "bytor" at May 16, 97 03:06:02 am

Dear R. Brock Lynn,
  [does R. stand for Robot as in I. Asimov's stories?]

> I have had an idea for a LOOONG time now to radically and completely
> rethink how Computer Programming should be done!
>
Welcome to the club!

> I finally, a few days ago hand wrote 9 pages worth
> of goals for a new Programming Language System.
Should you publish it on the WWW, I would read it.

> I only have had experience with [Pascal, BASIC, C, Asm]
There was a time when I was like you.
I admit I have learnt quite a lot since I discovered so-called
"functional programming languages" (actually, "higher-order languages"
would be better suited). You'll be pleased to discover OCAML and Lisp...

> Pascal was invented by a Mathematician Nicklaus Wirth,
> and I think some good thought went into it.
Pascal has lots of shortcomings, and Wirth promptly invented Modula-2
and Oberon afterwards. Many disagree with W. and others have developed
a Modula-3; besides, Wirth seems to voluntarily ignore functional programming.
   If you want a language with clean mathematical semantics,
learn lambda-calculus, and see ML (OCAML, SML), LISP (Scheme, CommonLisp),
Haskell (GHC, Hugs), Clean (Concurrent Clean). If you really want deep
insight of the relations between programming and logic, learn type theory.

> It is time that we abandon adding on to old languages, and totally
> rethink what a PROGRAMMING LANGUAGE should BE!
>
More than time.

> A new language needs to be designed that faces the future,
> not stuck in the past.
>
More precisely, I'd say that it needs
keep what was good in the past, and throw what was bad.

> Of course it would be best to have in the language specification how to
> interact with the "operating system" so that it would truely be portable
> with NO ( I repeat NO MODIFICATION ).
>
This already exists (Scheme, Common LISP).
However, unless the language is reflective,
programmers will not be able to have efficient extensions
to the little that can be standardized (and if they can't have
efficient extensions, they can't gather the information necessary
to standardize them well).

> Right now as we speak there is only one OS standard Spec,
> that of POSIX. but it is lacking.
Uh, Windows, MacOS? Sure, that's bloated and proprietary,
but that's precisely the vendors' goals.

> I'm glad to see someone already trying to tackle that problem.
> So I wish you VERY GOOD LUCK with your Tunes.
Thanks.

> But instead of designing one set OS, please
> try to design instead a new all emcompassing OS standard, such that
> anyone would then be able to create their own OS which conforms to that
> standard.
>
The case of Tunes is different,
because Tunes is a free, reflective architecture.
This means that everyone can access the source freely
(from an economical/political point of view),
and that everyone can change just the needed part,
without having to reimplement the rest (from a technical point of view).
Hence, there won't be that need both political and technical
to rewrite software from scratch many times.
Instead, there will be only One Tunes,
that will come in infinitely many flavors,
with more or less standardization,
but two systems always being able to safely and seamlessly interoperate.

> And then any program written with my not as yet designed Programming
> Language Standard, will be able to compile perfectly on any OS designed
> to meet the New OS standard.
>
The Tunes reflective architecture encompasses a unifying language framework.
If you are interested in language design,
I invite you to join the Tunes HLL effort.

> As you should know C++ does not as yet have a firmly agreed to specification.
I *now* does (though the specs is too bloated and complicated to be fully
understood by anyone, not talking about implementing it correctly).

> The ONLY fully spec'd Object language is ADA. but Ada is
> also old and antiquated!
See CLOS -- Common Lisp Object System. Or Eiffel.
Also Smalltalk, but it sucks, and SELF, but it is oversimplistic.
Dylan and BETA look good, but it looks like there will be
only one implementation of each, proprietary and expensive.
Many other OO languages have been specified *and* implemented
(CLU, ObjectiveC, ObjVlisp, EuLisp, CECIL, Sather, Modula-3, Oberon, etc),
but have not been successful for various reasons.
CAML, Perl, Icon, are lively languages that now have
standard OO extensions seamlessly integrated to the core.

> What is needed is stringent ORGANIZATION.
You mean a political organization to develop and standardize the language?
I don't buy it. See Eiffel, BETA, Clean.

> C is absolutely filthy, when it comes to org.
Oh, perhaps you mean *clean semantics*.

> variables can be declared anywhere at anytime,
Uh? They precisely can't!

> the "switch" control structure is horrible!!!
If that was the only defect of C, I'd buy it immediately.

> the fact that you can exit a looping structure
> at any freaking place by using "break" is utterly
> disgraceful.
break is a disgraceful thing,
but to me, the Right solution is that developed by the Scheme language:
to increase the expressiveness and allow full, first class, continuations,
in a higher-order functional semantics,
instead of of decreasing expressiveness (as you suggest),
and enforce lots of ugly boolean variables a la Pascal,
in a first-order procedural semantics.

> Spaghetti code should be a thing of the past.
First-order procedural languages, too.

> It's time for a mature Language, that is powerful, EASY to USE and
> understand, and built from the ground up based on sound and solid
> principals. Don't you agree?
>
In as much as you don't decrease the power to achieve understanding, agreed.
Principals: see lambda calculus and reflection.

> And we should also move away from simple text editing of the past.
Yup. Have you read the Gwydion manifesto?

> what we need is a specification for a new style Programming System.
Tunes.

> of course don't forget text only terminals.
Beware that Interface independance isn't the same
as dependance on the worst Interface!
See what I just wrote in the Interfaces subproject.

> such a spec should also be able to be
> carried out in such an environment. (virtual screen switching etc. for
> switching betw. running program and it's source file being interpreted.
> for debugging.)
See the Migration subproject.

> If you have any information or ideas I may not have on how to construct
> such a brand new and radically different Landuage System Standard Please
> email me at rlynn@ocean.st.usm.edu.
>
Well, I have many. The central point is Reflection.
And the theory of the past to build upon is formal semantics.
Check my HLL/ and Review/Languages.html pages...

> You may have heard of LINDA, [...]
The language with distributed tuples?
Ahem. It looked like a very restricted version of what Pi-Calculus allows.

== Fare' -- rideau@ens.fr -- Franc,ois-Rene' Rideau -- DDa(.ng-Vu~ Ba^n ==
Join the TUNES project for a computing system based on computing freedom !
                TUNES is a Useful, Not Expedient System
URL: "http://www.eleves.ens.fr:8080/home/rideau/Tunes/"