Re: What is an assembly language?


Herbert Kleebauer wrote:
> "randyhyde@xxxxxxxxxxxxx" wrote:
>
> > Prove that HLA is a "high level language".
> > The easy way to prove this is for you to provide a RosAsm source file
> > that cannot be converted, instruction by instruction, into an
> > equivalent HLA program.
>
> You already have been told many times, that this is the wrong way.

Oh, by people like yourself that have an axe to grind and are seeking
(for their own personal reasons) *some* mechanism for disproving that
HLA is an assembler.

> To proof that a human is not an ape you don't have to find something
> which the ape but not the human can do. The opposite is true, you need
> to find an essential ability of the human which no ape has.

So what is this essential ability of an assembly language that is
missing from the HLA language?

BTW, your analogy is flawed. Try substituting "primate" for "ape" and
asking the question again.



> To proof
> that a DVD player is not a CD player, you don't have to find something
> which the CD player can do but the DVD player can't do.

And that analogy is *really* flawed.

> Again the
> opposite is true, you have to find an essential ability of the DVD player
> which no CD player has.

Try subsituting CD-R for CD player.

> And to proof that HLA is not an assembler,
> you don't have to find an assembler program which can't be translated
> to HLA, but you have to find an essential ability of HLA which no
> assembler has.

So, by your analogy, if we find *any* unique feature that one assembler
has, not found in any other assembler, then that product is not an
assembler. That pretty much means that no such thing as an assembler
exists because *all* assemblers have unique features.

Even if we stick to assembly languages rather than assemblers, the same
idea applies.


> And that is pretty obvious and therefore it is pretty
> obvious that HLA isn't an assembler.

Sure. And neither is RosAsm, MASM, Gas, NASM, FASM, GoAsm, YASM, A86,
and so on, as they *all* have features not found in any of these other
products. Indeed, your own "assembler" wouldn't qualify as an "x86
assembler" has it has tons of things not send in *any* other x86
assembler.

You've made the most common mistake people make when trying to "prove"
that HLA is not an assembler -- you make up some rule that will apply
to HLA, not realizing that it applies to other products traditionally
viewed as assemblers. I'd say "nice try", but it's not like this is a
particularly original thought -- it's been tossed out many times in the
past.


>
> But first you should resolve your name conflict. If we are speaking
> about C, Basic, FORTRAN etc. then we are speaking about a language
> and if we are speaking about GCC, Visual C++, GW-BAsic etc. then
> we are speaking about a compiler which processes a source file
> written in the corresponding language.

Just as MASM, TASM, FASM, NASM, GoAsm, Gas, and even your little tool
process a source file written in the corresponding language. Yes. We
have a language and we have an implementation of the language.

> But you use the three
> letters "HLA" for both.

Technically, "HLA v1.x" is the implementation, "High-Level Assembly" is
the language. Generally, you can pick up the difference from context.
Granted, this distinction seems to be beyond many people's
comprehension around here, but given that I've made this distinction
over and over again since the first day HLA was released, you can
hardly blame me for that.


> Just call your language "HLA" and your
> compiler "PD-HLA" or "Randy-HLA",

As I said. That language is called "High-Level Assembly" and the
(current) implementation is HLA v1.x. "HLA" is often used as a
shorthand for both. It's generally pretty easy to tell them apart from
the context.

> then we get rid of one source
> of confusion.

No, because the concept of implementation versus language is *still*
beyond the comprehension of several people around here. You start
talking about "language" and people still get caught up in this mode of
"it emits a MASM file, so it can't be assembly..."

> The name of the language which x86 assembler (MASM,
> TASM, RosAsm, FASM, etc.) process is "x86 assembly language".

Every one of those assemblers you've mentioned processes a *different*
language. You do know a little formal language theory, right? Even MASM
and TASM, which have a common language subset, are *different*
languages. If they were the same, then both compilers could process
*any* source file that the other compiler could handle. This,
obviously, is not the case. Therefore, these compilers are
implementations of different languages. Of course, once you start
talking about these other assemblers, the situation gets even worse.
And then we throw in *your* assembler or Gas, and we've got a regular
tower of Babel on our hands.

The HLA language is syntactically different from the languages
processed by these other assemblers (just as they are different from
one another). Perhaps you could even claim radically different (though,
no more so than Gas, RosAsm, or your assembler). But that doesn't mean
anything. HLA certainly isn't Intel syntax. But there is no requirement
that an assembler follow Intel syntax in order to be an assembler.


> As you say yourself, Randy-HLA processes source written in HLA
> language (and not x86 assembly language).

Wrong. I do not make that claim.
HLA *is* an x86 assembly language. It isn't the same one as MASM. But
then, neither is NASM, TASM, GoAsm, FASM, Gas, or your assembler. Every
one of these is *an* x86 assembly language. You do understand the
concept of language hierarchy, right?


> Already this is shows,
> that Randy-HLA isn't an x86 assembler.

No. This doesn't show that. All it shows is that HLA is *different*
from all of these other languages. Just as all of those languages are
different from one another.

> Otherwise you wouldn't need
> a special name (HLA) for the language but could use the term
> "x86 assembly language" as all the other assembler do.

Every one of these language has their own special name. They're called
"the MASM language", "the TASM language", etc. They are not all one
single unified language. Not by a long shot. If they were, you'd be
able to feed the same program into any one of these compilers and they
would handle the file. That doesn't happen. They are different
languages. If you're going to create an umbrella classification of
"x86 assembly languages", then HLA is just as valid a member of this
classification as any one of these other languages, including your own.


> This is
> the same as compilers for C++ or C# are not C compilers.

Okay.
Now, are Borland C++, Microsoft C++, and GCC all C++ compilers?
I can assure you, these compilers do *not* process the same languages.
Each have their own extensions that are not present in the other
languages. Each have some omissions that the C++ standard calls for.
Each of them do some things differently than the others.

That being the case, can we claim that VC++ is *not* a C++ compiler?
(now I'm sure that some die-hards *will* make this claim, but that's
just as ridiculous as the claim that HLA is not an assembly language).



>
>
> But I don't understand why you insist on calling Randy-HLA an
> assembler?

It is a compiler for an assembly language.
And the only definition that works for the phrase "assembler" is "an
assembler is a compiler for an assembly language." Every other attempt
to define that term around here fails. People *try* to come up with
definitions to *exclude* certain products, but they wind up excluding
other products as well. For example, any definition that fails to
include MASM isn't acceptable -- to everyone but those who have a
vested interest in "punishing" Microsoft for their evil behavior, MASM
*is* an assembler. Indeed, MASM is the defacto-standard x86 assembler.
Yet every definition I've seen that attempts to exclude HLA also
excludes MASM. Hardly a working definition.

Then, of course, there are the definitions (like the ones you've tried)
that consist of picking a set of features common to a few favorite
products and claiming that anything outside this limited set means that
you no longer have an assembler. The most common attempt at this is the
"one-to-one correspondance" argument. It just doesn't fly.

> HLA is a computer language to write programs
> for x86 processors and Randy-HLA is a compiler which processes
> source files written in HLA.

Absolutely correct.

> You can even claim that HLA is
> far superior to x86 assembly language because you can express
> anything you can express in x86 assembly language and much
> more.

No. I do not make that claim. I claim that the HLA language is superior
to other x86 assembly languages, like the MASM language, because it has
superior features. I do not claim that HLA is superior to x86 assembly.
That would be absurd. That's like saying a "Mustang" vehicle is
superior to a Ford vehicle.

> But because of this "much more" it isn't x86 assembly
> language anymore and therefore you need a new name for it (HLA).

It's much more than the MASM language, not x86 assembly language. To
continue the previous analogy, a "Mustang" might be quite superior to a
"Focus".

>
> I suppose your problem is, that this new language HLA is
> worth nothing,

It must be worth something, if it is so much better than "x86 assembly"
(in your words).

> because the "much more" is still "much less"
> than languages like C, C++, C# or Java

I guess it depends on how you compare languages.
For many situations, HLA is certainly "much less" than these HLLs you
mention. That's understandable. Assembly languages are often considered
to be "much less" than HLLs by many people. I certainly don't have a
problem with that characterization.

> and for writing
> some small assembly subroutines for a HLL this "much more"
> is pretty useless.

Really?
Provide the proof of this.
Write some small assembly language subroutines for a HLL in some other
assembler than cannot be done exactly the same way (with appropriate
syntax modifications) in HLA.


> So you try to sell your HLA language as
> x86 assembly language which is specially designed to learn
> x86 assembly programming.

I'm not really "selling" it, but it was certainly designed from day one
as a pedagogical tool, yes. There is no "so" about it. "So" implies
that it was created for some other purpose, failed, and as a last
resort was delegated to becoming a teaching tool. This is clear
nonsense. HLA was invented as a substituted for MASM for the 32-bit
edition of AoA. Other than having a more powerful assembler for my own
personal use, there really was not other reason for creating it.


> But this is nothing but nonsense.

Really?
Prove that statement.


> If you want to understand the body of an ape, you don't dissect
> a human body.

If you want to understand the body of a primate, either will do.
Cheers,
Randy Hyde

.

Relevant Pages

  • Re: HLA StdLib2 criticism
    ... Assembler" (HLA). ... Can that person call this the "FASM language?" ... but also of course not he can call it an assembler ... Therefore HLC.EXE can't be called a compiler. ...
    (alt.lang.asm)
  • Re: What is an Assembler
    ... >> converts a HLA source to an executable. ... > knows the first thing about formal language design. ... convert an assembler source file to an executable (comparable ... it is a full compiler in every sense of the word. ...
    (alt.lang.asm)
  • Re: Evolution
    ... > inline assembler and larger parts by linking to an assembler ... in the HLL. ... language, particularly in smaller projects. ... > or two instructions if you ...
    (alt.lang.asm)
  • Re: HLA StdLib2 criticism
    ... HLC.EXE with an already existing C compiler and calls it HLC system. ... Suppose someone creates a new language and calls it "High Level ... Assembler" (HLA). ...
    (alt.lang.asm)
  • Re: What is an Assembler
    ... > Salomon offers the following definitions for a High Level Assembler (or ... > A high-level assembler language is a programming language ... > Here you use the same abbreviation (HLA) for two total different ... refer to these languages by the name of the compiler. ...
    (alt.lang.asm)