What are the primary differences between symbolic and high-level languages?

Answer 1

Symbolic languages have a near 1:1 relationship with the resultant machine code, thus the translation from source code to machine code is extremely trivial. For instance, the move instruction maps to several operation codes (opcodes) depending on whether the source and destination are working memory addresses or register addresses. However, there is no need to map each opcode to a separate mnemonic because the assembler can deduce the exact opcode from the operands alone. Thus all moves can be symbolised with a MOV mnemonic. So aside from choosing between opcode variants, translation from source code to machine code is relatively simple to program.

High-level languages have a higher degree of abstraction than symbolic languages (which is what we mean by high-level). A single high-level statement may generate many dozens of low-level instructions thus translation from source to machine code is far from trivial. However, programs don't need to be written in minute detail because the compiler handles all the machine-level details, many of which are highly repetitive (move values into registers, perform an operation upon those registers, act upon the result, rinse and repeat). This allows the programmer to express his ideas in code more freely.

Answer 2

Symbolic languages like assembler give the programmer complete control over the resulting machine code. High-level languages introduce a level of abstraction between the source code and the resulting machine code. The greater the level of abstraction, the less control you have over the resulting machine code, but the easier it is to write programs. However, while complex programs can be written relatively quickly, performance and efficiency tends to suffer as a result.

Answer 3

Symbolic languages like assembler language are low-level; there is very little in the way of abstraction between the assembler code and the resultant machine code, putting the programmer in complete control of the machine code. However, the programmer has to program everything in minute detail and the onus is upon the programmer to ensure the code favours the computer, not the programmer.

High-level languages are highly abstract; a single line of high-level code can easily produce hundreds of assembly instructions. While this greatly simplifies the overall coding process, the programmer naturally has less control over the resulting machine code. However, modern compilers can produce highly-efficient machine code so this isn't a major concern, particularly when using a mixed-mode language that allows you to incorporate assembler routines wherever it is deemed necessary. Thus the primary difference is that you can produce working code many times quicker than you could with assembler alone, and just as efficiently.

The high-level of abstraction also permits you to "visualise" your program more easily, especially when using a strongly-typed, object-oriented programming language. OOP allows programmers to use objects in a highly-controlled manner, re-using existing code without the need to duplicate that code, such that the programmer needn't concern themselves with the underlying implementation of those objects. The programmer need only concern themselves with what an object does, not how it does it, thus permitting underlying implementations to be altered without affecting the consumers of those objects. And with a strictly-typed language, the compiler can catch obvious bugs that might otherwise be missed in assembler. Ultimately, high-level languages favour the programmer, never the computer. That's solely the responsibility of the compiler.