What is a difference between a high level programming language and a low level programming language?

Answer 1

The most basic difference is that the statements in a low level language can be directly mapped to processor instructions, while a single statement in a high level language may execute dozens of instructions.

Low level refers to the fact that this is a machine language, binary in form, generally meaning one low level command = one executed instruction.

The complexity arises when we need to enable a programmer to designate one high level instruction that performs several or many machine (low level) operations.

Low Level Languages: Assembler and Advanced Assembler - see Compiler Languages.

High Level Languages: RPG, COBOL, any that make machine level programming of a computer easier.

Answer 2

High level programming languages are more structured, are closer to spoken language and are more intuitive than low level languages. Higher level languages are also easier to read and can typically sometimes work on many different computer operating systems. Some examples of higher level languages are Java, Visual Basic, COBOL, BASIC, C++, and Pascal to name only a few. Lower level languages are typically assembly languages that are machine specific. Computers run instructions at the binary level, interpreting zeros and ones as instructions. Rather than writing programming code at this level, we've developed languages that compile into the zeros and ones that computers understand. As these languages become more robust, they get further and further way from zeros and ones, becoming higher level languages. Today's object oriented computer languages allow developers to mimic the real world with objects in code. To use an analogy, high level programming languages are to spoken languages as low level languages are to Morse Code. Morse code is not limited in what it can communicate, but it's not as intuitive or easy to use as spoken language. Yes and Also... High Level Programming falls in the Area of OOP/Object Oriented Programming. They were design to get much out of Programming, more complexity, flexibility, in a presentation, in Simplicity. There was a time where all Programming was done in Machine Lanuages, which I can imagine... Gave Programmers a big Headache. Then b, was created then C, Then after awhile C++ Was created which was an adon to C, Making it High Level OOP. All though not all High level Programming is OOP. OOP Has to have . Polymorphism. Encapsulation etc etc.... Well Not all High Level Programming is OOP. PHP, PERL, RUBY, Which fall in the lines of ''Interpert'' languages, and differ from OOP. Anyway Low Levels actuially refer to The actual Memory, how the CPU Reads, and executes Data. High Levels Are powerful languages, but are presented in ''Human readable Codes'' Defining Variable Names, etc etc.

Answer 3

The level of abstraction. Low-level languages like assembler language have little in the way of abstraction, giving the programmer complete control over the architecture to produce extremely efficient code. The downside is that programs must be written in minute detail. High-level languages like Java and C++ are highly-abstract and allow the programmer to concentrate on functionality and rapid-application-development rather than worrying too much about the underlying efficiency. However, C++ allows far more control over the resulting machine code than Java because Java compiles to byte code, suitable for the Java virtual machine. As such, Java is more abstract than C++, but both are high-level languages.

Answer 4

A programming language that is machine-independent is called a "high-level" language - this includes Java, C++, Python, etc.

A programming language that is machine-dependent is called a "low-level" language. For PCs, this usually includes assembly, binary code or some proprietary languages on embedded devices.

Answer 5

Clearly the level is the difference. Low-level programming languages have little to no abstraction between the code we write and the code executed by the machine. Symbolic assembly languages are low-level because there is a near 1:1 translation between the source code and the assembled machine code. Low-level languages are machine-dependent languages; code is specifically written to suit one particular machine architecture thus the code is non-portable.

High-level languages have a much greater degree of abstraction between the code we write and the code produced by the compiler or interpreter. This makes it possible to write code in a machine-independent manner; the same source code can be compiled upon any architecture with a suitable compiler implementation.

The level therefore describes the amount of abstraction. However, this is merely an indication of the amount of abstraction rather than an absolute. High-level languages can also be used to write low-level code. C is a typical example because its instruction set closely matches that of the underlying architecture but is not specific to any one architecture. As a result, C is often described as a medium-level language. C++, on the other hand, has a much higher level of abstraction than C because it includes object-oriented programming principals. Although it is (now) a completely separate language from the "classic" C from which it primarily evolved, it can still be used to write low-level code in a C-like manner. As such, it is very rare that a C++ programmer requires anything more low-level than C++ itself. Virtually anything you can write in assembly or C can also be written in C++, the only difference being the level of control you have over the resultant machine code. However, the C++ compiler is highly optimised and can actually produce more efficient code more quickly than any human possibly could, thus greatly reducing the amount of interaction required between the programmer and the machine code itself.

Although low-level programming gives the programmer greater control over the machine code, it is more beneficial to pass the bulk of that control to the compiler so that we can concentrate on writing code that is much easier for humans to understand because code that is easy to read is also easy to maintain. With low-level languages we are much more reliant upon user-defined comments to keep track of the high-level concepts we are actually implementing in our code, but compilers do not read let alone understand comments and, more importantly, programmers cannot be forced to read let alone obey comments either. With high-level languages we can more easily express concepts directly in code and thus enlist the help of the compiler to ensure both we and other programmers adhere to our invariants.

Answer 6

Low-level programming is machine dependent while high-level programming is machine independent. That is, the same high-level source can be compiled or interpreted upon any machine with a suitable compiler or interpreter. In other words, you use high-level languages in order to more easily produce low-level, machine-specific code.

Answer 7

A low level programming language is for beginners of the programming world and usually goes easy. A high level programming language is for advanced/expert programmers who know a lot about how to program, and doesn't go as easy as a low level programming language.

Answer 8

A low level language is closer to the architecture of the computer and may be usable only on the one machine for which it was designed.

A high level language has a complex interface that permits it to be used on all, or a large variety, of computers. Its commands are translated in the background into machine specific commands. Examples of high level languages include C++ and Fortran