I always thought the word "compiling" was weird, as the standalone literal definition is akin to bringing a number of independent things together. That sounds much more like the linking step, than the individual "compilation" of a single source code file.

"Assembling" has sat better with me, as it's putting together the instruction line building blocks into binary form.

_________________
WFDis Interactive 6502 Disassembler
AcheronVM: A Reconfigurable 16-bit Virtual CPU for the 6502 Microprocessor

Here's a take on the terminological choice:


So we see here an emphasis on the time it takes go around from edit to test and back to edit, rather than on the complexity of the transformation.

I find it interesting that the common English meanings of both "assemble" and "compile" include the idea of bringing together some pieces for some purpose. One seems to me more three dimensional and the other more one dimensional. And yet we still have the additional technical term "link" for bringing together pieces even after they have been assembled or compiled.

I think Grace Hopper's use of "compile" was in the sense of stringing together useful library routines to make a program - in the days when such routines would include things like arithmetic. As memory is one dimensional, this seems fitting - each routine needs to end up with an address, the routines need to be in some order. In those days, each routine might also need to be patched with the calling addresses of the routines it uses.

(As I probably said elsewhere, I think it's not helpful to argue about terminology within threads about something else, and as with all communication, it helps for the reader to put in a little effort to understand the writer's intent. Language changes, over time and over distance. Better to learn someone else's dialect than to try to get them to change. We can still have an interesting discussion about the differences, in the right place.)

The OED (http://www.oxforddictionaries.com/definition/english/compiler) offers the following definition of compiler:

That is obviously a valid and correct description of an assembler (although "assembler" is more specific than "compiler").

It seems that the distinction might have been clearer a few decades ago. Something like this: The compiler was the tool that would transform a high-level language into a machine-specific representation, and the assembler was something that would take a machine-specific representation and turn it into executable code, via mostly simple one-to-one transformations. (And we still see what-we-call-compilers invoking what-we-call-assemblers for the final step. Not always, of course, but it's not an uncommon pattern.)

But I agree that the lines are most definitely blurred today, with systems that do dynamic translation (or "JIT"), compilers that output bytecode, optimization, and assemblers that include higher-level language constructs. When you take a step back, it all sort of blends together.


I remember reading an argument somewhere that as the various stages of transformations got their own names, like "linking" and "relocating", we sort of ended up with the word "compile" meaning what it does sort of by default, as the thing that was left over when everything else had its own name.

It was probably in a book on early computing history, but I can't remember the name now.



Very true. Vast amounts of heated online discussion exist only because two people have different definitions of terms. I'd add that it takes self-restraint and energy to step back and try to examine a discussion from a neutral point of view, and a willingness to risk looking weak to post something else than "you're wrong!" in order to dissolve disagreements. We're often not very good at that sort of thing.

So true. And anyways, in 2016 if some guy wants to say he compiles his program then he should be allowed. If you're here chances are you know what he's talking about. It's not really a big deal, and assembly language programs can be quite complex today, many orders more so than 30 years ago. I know my own programs don't exactly fit the pure definition of assembly language as I would have defined it in 1986, but my programs (as an example) are much more involved today and, even though they're technically 100% assembly, it's a multi-step process by which some custom stuff (scripts, raw binaries including graphics and audio, high level macros, regular source text, putting the whole thing into a disk image, etc.) is drawn from many files and a binary pops out at the end -- you could even say it is compiled and I certainly wouldn't argue with you, so who's to say? I contend the programmer who put the thing together has the final say and that there is no need for the word police (who watch from the bleachers anyway).

The pure assembly language programmer will by nature probably gravitate toward "assemble" while he with the HLL background may go with "compile". Either way is just fine with me.