High Level Language

A HighLevelLanguage is a ProgrammingLanguage that supports system development at a high LevelOfAbstraction, 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 ApplicationDomain 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 PrematureGeneralization.

Starting a development effort at a low level of abstraction often leads to PrematureOptimization. Also see TopDownProgramming and BottomUpProgramming.

Working at a high level of abstraction does not necessarily preclude runtime efficiency of the implementation. Many modern languages (e.g. CeePlusPlus, CommonLisp, AdaLanguage) 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 FortranLanguage 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.

See Also AlternateHardAndSoftLayers, CeeAsAnIntermediateLanguage, NthGenerationLanguage, DomainSpecificLanguage.

Contrast with LowLevelLanguages like AssemblyLanguage. [EditHint: the bottom area needs a re-arrangement]
Some ProgrammingParadigms appear to be at an intrinsically higher level of abstraction than others (compare DeclarativeProgramming with ImperativeProgramming). See MeasuringAbstraction, and LanguageOrientedProgramming.
Perhaps some languages, like LispLanguage and ForthLanguage, should be given the class of VariLevelLanguage?, since the level of abstractions offered by the language depends directly on how much you've altered the language to suit your problem domain? --SamuelFalvo?

I prefer 'MetaLanguage' for languages that allow you alter the language or create DSLs.


CategoryAbstraction CategoryProgrammingLanguage

EditText of this page (last edited August 24, 2014) or FindPage with title or text search