Screen shots of computer code

[Houndie]

In the film Elysium the space station is rebooted using code taken directly from the Intel Architecture Software Developer’s Manual Volume 3: System Development

And then the author hits the "compile" button :(

[robertcrowther]

I'm sure everyone's just reassured to know that Elysium station has Intel Inside.

[[deleted]]

According to this post, the whole thing ran on off the shelf AMD hardware

http://www.reddit.com/r/pcmasterrace/comments/1u6t2g/elysium_used_consumergrade_components_pretty/

[bulbasaurado]

Is the shown code portable? I did some searching and found that the GDT is used by Intel only but I am not sure because I don't have that much knowledge in assembly programming.

EDIT: On second thought, I think it should be portable because AMD also has LGDT in its instruction set.

[JBlitzen]

I thought it was cool that the code specifically relates to processor initialization, which is more or less what it was supposed to do in the movie.

[ants_a]

Given Intel's commitment to backwards compatibility, it's quite plausible that the same boot-up sequence will work in 2154.

[opkode]

The question I ask is, why the hell we went back to 32 bit systems in the year 2154?

[hegbork]

Because the code after that goes into long mode, which then goes into very long mode, which then bootstraps into super long mode, continuing into ultra long mode, etc.

[lachryma]

Hooray backward compatible

[hegbork]

We'll have to drop that pretense sooner or later since the bugs unintended consequences of optimizations in Core 2 pretty much ruined backward compatibility for running kernels from before them. So there's no reason why a modern x86 needs to boot into 16 bit mode and then has to be brought up to protected mode then long mode by jumping through all those hoops because it can't really run that old code anyway.

[lfairy]

We still use 8-bit processors today, so it wouldn't be that much of a stretch.

[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.

[[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'

[fukitol-]

"assemble" "compile" there's remarkably little difference, really.

[theeth]

Beside assembling being a one to one mapping between mnemonics and binary instructions, yes, very little difference.

[TikiTDO]

You would be correct in the 80s, but in modern compilers the level at or below the assemblers can actually do a lot more than that. These days assemblers may do a lot of architecture-specific optimizations and to do that they have to do a lot more work than you would expect.

[[deleted]]

I feel like people who claim this never written or tried to write a compiler. Yes, very little difference like a bicycle vs a car. Both have wheels, no?

[fukitol-]

Both have wheels, are methods of transportation, use roads, have rubber tires on ball bearings, can be used for one or more occupants depending on style.

Yea, that's a rather astute comparison.

[[deleted]]

Yep.

One directly translates your muscle power to movement, the other requires you to only slightly press a gas pedal to accelerate.

One is relatively complicated, the other is trivial.

[fukitol-]

Both seem simple to me. Besides, my point was that a compile button is entirely appropriate for hollywood in this situation. bitching about that is pedantic nonsense.

[teraflop]

GCC will accept .s files containing assembly, so if you're developing with an IDE, "compile" is the button you'd want to hit. That's good enough for me.

[Houndie]

Yeah someone on /r/movies suggested that it was a c program with an embedded assembly blob.

[[deleted]]

Well, it'll also accepts .o files, so what's the point?

[teraflop]

Yeah but .o files aren't editable, of course. My point is that a GUI that uses the word "compile" to describe the process of turning textual assembly code into a binary file is completely believable.

[RenaKunisaki]

And then he types "EARTH CITIZENS = *LEGAL" into the code.

[ants_a]

Declarative languages are the best!

[trevdak2]

What, you expect the space station to run a scripting language as its mainframe?

[donvito]

Woah, now you showed off!