Thu, 4 Apr 1996 05:50:05 -0500 (EST)
On Wed, 3 Apr 1996 email@example.com wrote:
> But at some point, the CPU has to execute code. It's all fine and good to
> say that something like '(add thisvar tothatvar withresulthere)', but
> something somewhere is going to have to convert '(add thisvar tothatvar
> withresulthere)' to
> mov eax,[thisvar]
> add eax,[totharvar]
> mov [withresulthere],eax
> or something eventually. That's the one thing that has bugged me about
> you Tunes guys, you seem to expect this stuff to happen automagically.
> Sorry, that ain't going to happen.
> Okay, there seems to be some fundamental communications problem here as to
> what is what. More on this later ...
Yes, that's part of what I'm trying to deal with.
[what is LLL?]
> It depends upon what you consider low level. I know Fare things LISP is
> low level (!) whereas I tend to think of assemly as low level.
> > Unless you want to write a lot of low-level code directly, you don't
> > need a language like Forth with a syntax, modules, name-spaces
> > (vocabularies),... These are considerations for the human writing the code.
> > A intermediate stack language (as is often used in compilation) is enough.
> > It does not need to have it own character-stream syntax, its programs can
> > simply exist as a structure of (Scheme for now) objects in the compiler.
> > Giving it a character-stream syntax CAN be done but you start to
> > want a lot of language features for humans (name-spaces,...).
> It might be anachronistic of me, but I tend to want to look at the low
> level code sometimes, as that may be the only way to solve a particularly
> nasty problem (in porting joe to QNX, I ended up having to look at the
> generated machine code to see that the frame pointer was being trashed
> somehow and tracking it back to the problem). Have you ever SEEN code
> output from a compiler (say, like GCC)? It's not readable by any standards.
> The Unix weenies tend to say "Well, assembly isn't for humans."
Neither is s-exp...
> As a result, the assemblers found on Unix systems tend to be pure trash
> with a syntax that I find exceedinly offensive (and make MASM look beautiful
> by comparrison). You may find that the low level stuff doesn't need a
> 'character-stream syntax', but at what point is the cut-off made?
Also, a question of who's going to do what. Do the people objecting
propose to write everything in HLL? No, that's why there's an LLL, which
must have a certain amount of functionality. I happen to want to do some
other things with the LLL, possibly unrelated to the Tunes project, and
for that, I need to have a usable language.
> > If the LLL is to be the (portable) language to which the HLL compiles
> > (when it wants to), then Forth would not be the LLL (I wouldn't want
> > to compile to Forth) but another language that is compiled to the LLL
> > in a straightforward way. But I'd rather have this language be (as
> > much as possible) a subset or something similar to a subset of the HLL.
> What's wrong with Forth (or a Forth-like lanaguage)? You said yourself
> that most compilers output something akin to a stack based language, with is
> But what you are saying is you want:
> HLL -> (some other representation) -> LLL
> But then isn't the LLL:
> LLL -> (some other representation) -> CPU code
Not for me! LLL->cpu code, plus environment.
> That's some five levels of compilation. The more I think about this
> HLL/LLL concept, the less I like it. Because if I understand the end
> results, you'l have something like:
> C -> HLL
> Ada -> HLL
> <insert your favorite nonHLLtype langauge here> -> HLL
> Then how is the HLL any different than the LLL (except for some vague
> automagical stuff like DWIM)?
Good question. I don't really think C -> HLL will ever work, but that's
not _my_ project. :-)
> > Unless absolutely necessary, I guess we shouldn't define this kind of
> > thing in the LLL. It is the HLL which will guide the selection of
> > these things. Hmm.. damn I don't like this LLL/HLL dichotimy at times.
> > They are linked so tighly that idealy you'd have only one genius
> > desing the whole thing in one piece. Since that's not going to happen,
> > we'll need a lot of communication.
> Technically, such definitions are beyond the scope of a language
> definition and are defined in terms of the OS, which is independant of the
> language (certain 68k Assemly, BCPL and C (all of which AmigaDOS is written
> in) don't have 'process' or 'task' as part of the language).
> An OS is written in some language (or languages). It's NOT the language.
> Now, part of the environment of the OS may be integration into an IDE with a
> language (tradition Forth systems are like this), but there is a distinction
> between what is done (OS) with how it's said (the language the OS is written
I'm expecting that LLL, or at least what I'm writing ( ;-), will have the
task of containing the lowest level OS code, as well, so I would need to
know how much of the context switching will be dealt with at higher
levels, and what model will work the best for the LLL.
[lexical scoping in LLL]
> > Hmm... lexical scoping. I take that for granted. Scheme has it. The
> > HLL will have it. Why redo it again for a Forth-like language ?
> At some level, lexical scoping has to be defined. It seems that the HLL
> lexical scoping will be done in terms of the Scheme lexical scoping. But
> where is the Scheme lexical scoping defined? The buck starts somewhere ...
> And again, I hate to interject hard concrete implimentation icky icky
> details into this discussion, but WHAT IS THE LLL AND THE HLL? I'd even go
> so far as to ask WHY EVEN BASE THE OS ON A SINGLE LANGUAGE? but the last
> time I asked that the consensus was to do it anyway, like every other OS
> ever written.
> So, to kick things alongs, someone, please, define the following:
> and their relationships.
I've been operating under the assumption that the LLL would be both the
bottom level language and environment, and most/all of the CPU specific
parts of the OS, with decision making being concentrated in the HLL. The
HLL would (eventually) become a superset of LLL, with the LLL mechanisms
(such as the hypothetical vocabularies) being used by the HLL to build
the higher level things.
At least, that's what I was thinking.