In computer programming terminology, programming languages are often separated into "high-level" and "low-level" languages. The difference between the two is a matter of hardware interaction. Simply put, low-level languages reside "lower" on the computer system, closer to actual hardware interaction. High-level languages are abstracted away from the hardware. The result of this abstraction can result in quicker, more readable code, but lower speed benefits and less access to system resources.
What makes high-level languages different from low-level languages is the level of abstraction a language has from system resources. Dealing with system resources on a daily basis can become slow and painful. High-level languages were created to deal with this issue by handling the system for the programmer, freeing her to complete more advanced task while ignoring the minute details of the system, such as memory management. However, this has a drawback in that a programmer might find herself in a situation where system access is required, and a high-level language cannot give that access. A high-level language is typically not suitable for systems programming.
High-level languages are typically "interpreted" languages rather than the "compiled" low-level languages. "Interpreted" simply means that a language uses an interpreter that executes source code one line at a time, rather than compiling a binary file. However, interpreters are often programs written in compiled languages. Because of this, the interpreted language -- Python, as an example -- only runs on top of the Python interpreter, which is written in C. This increases the memory and time overhead for interpreted programs, and they often execute more slowly.
Video of the Day
A seeming strength of high-level code is its portability. High-level code can run on any system that has the appropriate interpreter installed. However, when a program is compiled for a computer, it takes into account the entire environment of that system in its compilation. An interpreted language is already abstracted from the system to such a point that the interpreted program knows nothing about the system except for what the interpreter can supply it.
Because of the nature of high-level languages, there are certain tasks for which they are not suited for, or at least not yet suited for. Without access to system resources, developing quick, OS-native applications is difficult. Furthermore, even developing an operating system becomes problematic. As more software moves online, this fact becomes less of a concern but, for commercial and industrial usage, interpreted languages may work too slowly, or too far removed from hardware interaction.