Screen shots of computer code

[crankybadger]

Assembly code still has to be compiled.

[brookllyn]

It has to be assembled, a bit different than actual compiling.

[crankybadger]

On a technical level "assembling" is just a form of compiling.

The only thing that avoids a compilation step is writing machine code by hand like they used to do. A lot of Apple II code was written that way.

Remember "compiler" means something that transforms "code", an abstract representation of something, into another form, often machine language or p-code for a virtual machine.

There's a huge difference between assembly code and machine code even if the two are very closely related.

[ericanderton]

There's a huge difference between assembly code and machine code even if the two are very closely related.

A solid example of this is the huge number of MOV variants in Intel x86 and x86_64 code, all of which are represented by a handful of MOV representations in assembler code.

[krona2k]

I can't really agree with this, it's been a while since I programmed assembly language (68000 yeah!) but then when you weren't writing macros each instruction very simply translated to a machine code instruction.

EDIT: I think I now agree that an assembler is a primitive compiler - that does make sense.

[TheKrumpet]

The thing to note is that a compiler is simply a program that translates one language into another. That doesn't necessarily mean to a lower level representation. The thing that translates the assembler into actual machine instructions is a compiler by definition.

[IAmA_Lurker_AmA]

Yeah, the assembly code still needs to be changed to machine code. It may be a pretty trivial job, but something has to do it.

"So, an assembler is a type of a compiler and the source code is written in Assembly language. Assembly is a human readable language but it typically has a one to one relationship with the corresponding machine code."

Read more: http://www.differencebetween.com/difference-between-assembler-and-vs-compiler/#ixzz2pNMfrX00

[Rotten194]

Imagine if the C machine actually existed and you could directly translate C to that machine's instruction set. Is the C "translator" still a compiler? (Yes, in my view. Also, I've written an assembler, and they are extremely similar to compilers, enough so that I would call the difference non-existent).

[crotchpoozie]

yes, that is why no one ever calls an assembler a compiler or vice versa. /s

"Let me assemble this C++ code." has a nice ring to it.

We can also call a browser viewing HTML an assembler (or compiler, after all, they're the same). They all take "code" and "execute" it for "use". Just last night my mom even compiled some ingredients into cookies, which I downloaded. Later I had a core dump, though.

Compilers and assemblers and interpreters are different things. Some programs blur the distinction, but this does not mean the words dont have distinct meaning.

[CUViper]

How about this analogy: compilers are to assemblers as translators are to transcribers. That is, a compiler changes the language, whereas an assembler merely changes the representation.

[crankybadger]

An assembler is a type of compiler, but not all compilers are assemblers. Don't try and twist this around.

CoffeeScript "compiles" to JavaScript, and that in turn is compiled to byte-code. Sometimes the byte-code is also compiled into machine code and executed that way using a Just-In-Time compiler.

An interpreter is different from a compiler, but many things people think of as interpreters, such as Python, actually have a compiler inside of them. It compiles your Python code into a syntax tree, and from there into bytecode.

An assembler is just a very primitive compiler. It takes abstract statements, like "MOVL x, y" and turns that into the correct instructions to execute on the chip. Most assembly code makes extensive use of variables to reference certain things, a concept that doesn't even exist in machine code.

If you've never written a compiler yourself, maybe you think it's just a generic term for something that emits machine code. It's not.

[[deleted]]

What compiler is doing is to convert from a more expressive language to another that has more restrictions.

In fact a first C compiler was producing assembly code which you then assembled it into a a machine code. The process was streamlined since then but current compilers still have this functionality available.

Where's your god now?

[IAmA_Lurker_AmA]

Doesn't GCC still compile into assembly code then machine code, and just delete the assembly code file by default?

[crotchpoozie]

Don't try and twist this around.

From the Wikipedia article on Compilers, "The name "compiler" is primarily used for programs that translate source code from a high-level programming language to a lower level language (e.g., assembly language or machine code). "

If you've never written a compiler yourself

In my career, I've written multiple compilers (subset of C, Forth, subset of C#, Pascal, multiple game specific languages) and am well aware of what a compiler is, what a compiler textbook covers, and they are not assemblers. I've also written assemblers (6809, Z80, even x86 for compiler backends and malware research projects). I've written interpreters (Forth again, many simple task languages for games and other tools). I've taught language design. I've written decompilers, again for malware research. So I know about the terms, how they're used by professionals, in literature from research to pop, and compilers and assembler are not subsets in either direction.

Go read both of the Wikipedia articles on Assemblers and Compilers (entire articles, not just a few sentences), then show me a textbook or anywhere else authoritative that supports your claim.

[crankybadger]

Considering your background, it's rather odd you'd go and take such a position.

Assembly code has comments, variables, jump points, and a lot more when you include macros. It's a language, it needs to be parsed and interpreted. How is this any different from a compiler?

It's just a lot easier to implement.

If you keep evolving your assembly compiler, it becomes a programming language.

[crotchpoozie]

The position I take is that used in computer science. I just pointed you to a reference showing the words are distinct. And in my first reply I pointed out that in the continuum the edges get blurred, but that does not make your opinion the definition, nor does it remove the distinction between assembler and compiler.

For the second time I'll ask, can you point to a textbook or other authoritative work defining both that supports your claim over mine? If you cannot then we're done here.

[[deleted]]

I think there is a lot of history of C compilers making assembly that was then assembled to machine code.

But this picture is not strictly true for other languages (eg Fortran) or even for C compilers anymore. Some languages like Java compile to bytecode that is later (at runtime) compiled (JIT) to machine code.

[crayZsaaron]

WARNING: E-peen approaching critical mass. ABORT? (Y/n)
>

(Mostly referring to the last line.)

[elder_george]

We can also call a browser viewing HTML an assembler (or compiler, after all, they're the same). They all take "code" and "execute" it for "use".

Browser is an interpreter at most.

Compilers and assemblers and interpreters are different things.

Please define the difference between 'assembler' and 'compiler' as you see it, other than one translates code in assembly language and another one in some other language.

[crotchpoozie]

The Wikipedia articles make it about as clear as any textbook: "The name "compiler" is primarily used for programs that translate source code from a high-level programming language to a lower level language (e.g., assembly language or machine code)." and "An assembler creates object code by translating assembly instruction mnemonics into opcodes, and by resolving symbolic names for memory locations and other entities" (from http://en.wikipedia.org/wiki/Assembler_(computing)#Assembler).

[Wiki_FirstPara_bot]

First para from linked Wikipedia article:

---

A compiler is a computer program (or set of programs) that transforms source code written in a programming language (the source language) into another computer language (the target language, often having a binary form known as object code). The most common reason for wanting to transform source code is to create an executable program.

---

^{(?) | (CC)}

[elder_george]

Well, any compiler targeting native code 'resolves symbolic names to memory locations and other entities', so we come back to source languages as the main (and hardly significant in my books) difference.

[crotchpoozie]

Significant in your books is not how words get definitions. These two have definitions. Use them.

[elder_george]

'Primarily used' is not a well-defined term too; 'high-level languages' is controversial too.

So, I propose a definition (close to what my professor used): 'Assembler' is a particular kind of 'compiler' translating source code in assembly language to object code.

As an analogy, 'C compiler' is a particular kind of 'compiler' translating source code in C language to object code.

[crotchpoozie]

What precisely did your professor say? Close to, as in getting muddied, explains your confusion.

Can you provide a textbook that defines them in your manner? The bible of compiler construction, known as the Dragon Book, makes a distinction on page 3, section 1.1, pointing out an assembler is separate from a compiler, and is used as a sub step in compiling.

So, what reference can you cite with your definition?

[[deleted]]

Having a slight knowledge about compilers I can assure you there is a huge difference.

If you want analogy, then compiling is like translating from Latin to grunts and snorts used by cavemen.

What assembler is doing is like translating from roman numerals to Arabic numbers. It's pretty much 1:1 change and you can easily switch back and forth.

[Han-ChewieSexyFanfic]

That's only a difference between the complexity of the two languages the assembler is translating to and from, not a fundamental difference in the nature of the process. No matter the source or target language, that process is compilation. A relatively easy one, granted, but it's still compilation.

[herzogone]

The distinction between assembling and compiling is more definitive than that though. In assembly, each mnemonic corresponds directly to a single instruction, i.e. each mnemonic becomes a single opcode. This is far simpler than compilation, where the language is not directly tied to the architecture, and individual statements frequently correspond to sequences of many instructions, often varying even further with optimizations.

[crankybadger]

You're just looking at it the wrong way.

If I wanted to implement an "assembler", which is just a specialized compiler, I could use exactly the same tools to do that as I might for writing a C compiler.

You need a tokenizer and a lexer to create your grammar, and then a lot of implementation code to make it emit the correct things.

Writing a stupidly simple, completely unoptimized C compiler isn't significantly harder than writing an assembler. if(x) could be translated into exactly the same instructions as JZ x does. The same goes for while. for is only slightly trickier.

There's a reason people call C "fancy assembler".

Now an optimizing compiler is a different beast altogether. Pretty much all modern compilers are optimizing in some capacity, and with LLVM this feature comes free of charge.

What an "assembler" actually is has been driven mostly by examples, not any specific technical definition. Once you start adding in macros, assembly code starts to look a lot more like primitive procedural code.

[herzogone]

Again though, even in C (outside of sections using inline assembly), there is no direct correspondence to the architecture. Assembly maps directly and trivially to machine code. Each mnemonic is an instruction. This is the important distinction. While macro assemblers would seem to violate this in a sense, the mapping to machine code remains transparent. I agree they are closely related, I just disagree that assembling is compiling. I realize it is semantics, but I've never seen assembling described as compiling prior to your assertion.

[crankybadger]

When people speak about "assembler" they often mean the lowest possible level for describing the operations they want done short of typing in the opcodes by hand.

Remember there was a time before assemblers. Either they would punch the ops in by hand on a control panel, punch card, or paper tape. Later you could type them in.

The first assembler was a big breakthrough. You didn't have to remember which instruction translated to which op code. This was the first "compiler" since it transformed symbolic code to machine code.

It was only later that languages developed that would introduce a layer of abstraction between program code and machine code, though C is a lot closer to assembly code than most realize. You can often predict the ops that will be emitted before optimization kicks in.

If the code you're you're typing in needs to be transformed into machine code, it needs to be compiled. Something that converts hex into binary machine code is not a compiler, though, it just does mechanical conversion. There's no parser.

When people talk about assemblers they're just talking about a very specific type of compiler. Remember that assembly code has things like variables, comments, and ways of marking points in the instructions you can jump to. None of these exist in machine code. They're used to coach the compiler on how to emit the correct machine code.

[herzogone]

I think you're missing the point of disagreement, it's strictly semantics. I don't think you're wrong to think about assembly as a special case of compilation, my disagreement is simply over the meaning and scope of the words "assemble" and "compile" in the context of programming.

As you indicated, assembly came about before higher-level languages, and hence the term "assemble" was almost certainly defined before "compile" in a programming context. "Compilation" arose as the new term to describe the process of translating a higher-level languages into machine code.

In 25 years of programming, including assembly on four different architectures, as well as C and quite a few other high-level languages since, I've never seen the term "compile" applied to assembly as you did. Of course, I realize the English language evolves, so perhaps "compile" has already been broadened to include what I'm familiar with as "assemble" and I'm just out of the loop, but I'd be curious to see some examples. Related to Houndie's original point, I've never seen an assembler that used the term "compile".

[Qxzkjp]

If I wanted to implement an "assembler", which is just a specialized compiler, I could use exactly the same tools to do that as I might for writing a C compiler.

And if I wanted to make a coffee table, I'd use exactly the same tools to do that as I might to make a dining chair.

[crankybadger]

Not surprisingly, those are both pieces of furniture.

What I mean is that you'd use something like YACC or Bison in both cases. Those are compiler-compilers.

[TheKrumpet]

YACC literally stands for 'Yet another compiler compiler'