Zoomtook

A high-level language is an advanced computer programming language that isn't limited by the computer, designed for a specific job, and is easier to understand. Today, there are dozens of high-level languages; some examples include BASIC, C, FORTAN, Java, C++ and Pascal. These are independent of the internal machine code of any particular computer.

High-level languages are used to solve problems and are often described as problem-oriented languages; a low-level language is the opposite of a High Level Language. It is one which exposes a significant amount of the computer's inner workings; for instance, in C Language, one deals with the concept of memory and pointers, whereas in Haskell Language, there is no concept of storing data. This aspect of CeeLanguage is low-level. The lowest-level language is MachineCode, which hides no details of the machine; not even the bit patterns used to form instructions are abstracted.

Low-level languages have the advantage that the programmer is able to tune the code to be smaller or more efficient, and that more system-dependent features are sometimes available. They have the disadvantage that they are often (usually?) harder to program in.

In computing, a low-level programming language is designed for a particular computer and reflects its internal Machine Code; low-level languages are therefore often described as machine-oriented languages. They cannot easily be converted to run on a computer with a different central processing unit, and they are relatively difficult to learn because a detailed knowledge of the internal workings of the computer is required. Since they must be translated into machine code by an assembler program, low-level languages are also called Assembly Languages.

A mnemonic-based low-level language replaces binary machine-code instructions, which are very hard to remember, write down, or correct, with short codes (mnemonics) chosen to remind the programmer of the instructions they represent. For example, the binary-code instruction that means ‘store the contents of the accumulator’ may be represented with the mnemonic STA (STore to Acummulator).

In contrast, high-level languages are designed to solve particular problems and are therefore described as problem-oriented languages: for example, BASIC was designed to be easily learnt by first-time programmers; COBOL is used to write programs solving business problems; and FORTRAN is used for programs solving scientific and mathematical problems

A High Level Programming Language is a Programming Language that supports system development at a high Level Of Abstraction, thereby freeing the developer from keeping in his head lots of details that are irrelevant to the problem at hand.

Starting a development effort at a high level of abstraction often leads to shorter development time since it retains opportunities to specialize the design, e.g. to adapt it to unforeseen insights into the Application Domain or to incorporate changing requirements. It is usually harder to generalize a specific design than to specialize or extend the design, since unanticipated generalization may force the re-examination of many existing relations between the constituents of the system to identify hard-coded design decisions that may have been invalidated. However see Premature Generalization.

Starting a development effort at a low level of abstraction often leads to Premature Optimization. Also see Top Down Programming and Bottom Up Programming. Working at a high level of abstraction does not necessarily preclude runtime efficiency of the implementation. Many modern languages (e.g. C Plus Plus, Common Lisp, Ada Language) aim to provide access to low level elements of the implementation while retaining means to develop at a high level of abstraction. Most language implementations allow to drop out to a different language to implement specific parts of a system at a lower level of abstraction.

The term "High Level Language" was originally used to distinguish things like Fortran Language from things like assembly language. Therefore, originally "high level language" very much included Fortran, Basic, COBOL, PL/I, and a little later, C.

Observing that such languages are not very high level compared with e.g. Prolog, YACC, Lex, ML, Haskell, etc, some people started calling the older high level languages "low level languages", or qualifying them as "higher level languages", etc. This is is often erroneously thought to be revisionism but is the very basis of much of Computer Science, and such terminology while not universally accepted among all programmers, is at least understood by those with a broad understanding of the relevant foundations of the topic at hand.

A more diplomatic approach to the topic, while sacrificing accuracy to appeal to the less-disciplined mind, would be to simply call more sophisticated languages "very high level languages", if a distinction is needed, rather than trying to snidely imply (or state outright) that there's no difference between assembler and Fortran, Basic, COBOL, PL/I, C etc.

No one who has done extensive programming in assembler would ever make the mistake of calling such things "low level languages"; there is a very sharp and painful difference.