I'm reading the "Art of Assembly" 2nd Edition by Randall Hyde. In the book the author seems uses his own language called High Level Assembly (HLA). Coming from a C Background, I question how useful this is in learning (real x86/NASM for use on Linux) Assembly. But, looking it up there seems to be a term "High Level Assembler" (wikipedia) that gives some credibility to calling HLA "Assembly".

HLA provides ENUMs; bounds checking; multi-dimensional arrays; constant, static, and readonly variables; operators; a standard library; some error-catching; alignment and a lot of other stuff.

Where is the line drawn between an Assembler and a Compiler. From the book, it seems there is even some addressing modes not supported by HLA,

Actually, the 80x86 does support addressing modes involving certain 16-bit registers, as mentioned earlier. However, HLA does not support these modes and they are not useful under 32-bit operating systems.

If it is a compiler, then does it "compile" the Assembly, or "assemble" the Assembly? Or is "High Level Assembly" just a procedural programming language that has little to do with Assembly?

  • 1
    $\begingroup$ I found the 16-bit AoA much more colorful, though not particularly due to the use of HLA in the second edition. $\endgroup$ May 15, 2018 at 1:19
  • 1
    $\begingroup$ Assemblers ARE compilers. Compilers translate one language to another language. Assmblers translate assembly to machine code and are thus a kind of compiler. $\endgroup$
    – xuq01
    May 16, 2018 at 7:39

1 Answer 1


The verb assemble and the noun Assembler is useful when it's important to point out that the program generates machine code with a 1:1 correspondence to the atomic instructions of the (Assembly) language.

But only a few simple directives (e.g. macros) need be added to the Assembler to reach something that gives more readable and compact code that can be, for all intents and purposes, considered high level.

If this was all that was added, you supply the actual macros, e.g. FUNC, CALL, STRUCT, etc. yourself, and can build your own language.

These macros are not the atomic Assembly Language instructions; nor are the directives built into the Assembler that lets you create them. Neither the macros you write, nor the directives are part of the agreed-upon Assembly syntax for the CPU.

For most intents and purposes, Compiler can be substituted for Assembler, and it's clear that you mean the program that generates an exe from text (or a tool). Perhaps some distinction could be useful when you mean language-specific such programs that can't parse Assembly, but there are ones that can do both.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.