• Advertisement
Sign in to follow this  

High-level and Low-level languages.

This topic is 1908 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hi, I'm a beginner in the world of programming, I was just curious, what are high-level and low-level programming languages, and what are some examples of those, also any example will be helpful. I hear those terms quite a lot and I don't know what it means.

Thank you.
- Manny

Share this post


Link to post
Share on other sites
Advertisement
Wikipedia is your friend for examples.

At the lowest (reasonable) level, you will have Assembly code.
Slightly higher level you'll have languages like C and Fortran
At a higher, but still low level, you'll have languages like C++ and D
Then higher up, languages like C#, Java
Higher up again you'll get things like Haxe, JS, Python
At probably one of the highest levels, you'll get languages like Prolog, Haskell, Agda


The lower the language is, the more closely it will match the underlying machine architecture, Assembly you're working with mostly individual machine op-codes with a human friendly name. C adds things like named variables, scopes, expressions etc. Once you get to the level of Haskell, you're very well removed from underlying architecture almost all together. Edited by luca-deltodesco

Share this post


Link to post
Share on other sites
What languages are "low-level" and "high-level" can be a matter of perspective... A "low-level" language is a language which is more closely attuned to the underlying architecture of the machine, whereas a "high-level" language is more "human-friendly" and abstracted...

If you ask a web developer or Python programmer what C is they will tell you C is a "low-level" language... but if you ask an OS programmer from a Linux project they will probably tell you C is a "portable, high-level programming language"... However, all will tend to agree that assembly languages are low-level because there is generally no abstraction whatsoever -- just op-codes that represent binary operands...

Share this post


Link to post
Share on other sites
In general, we can easily read high level languages but not low level languages.

In C++ or Java for example, we can obviously know what's going on
[source lang="cpp"]Game.load();
Game.run();
Game.shutDown();[/source]

but it's hard to understand the low level languages like assembly or machine code

[source lang="plain"]MOV AL, 1h
MOV CL, 2h
MOV DL, 3h
10101001100101010010100[/source]

C is low level language compared to Java or Python in that it provides access to "low level stuff" such as memory address, but is high level language compared to assembly/machine code in that it uses keywords similar to English. Edited by lride

Share this post


Link to post
Share on other sites
the thing is, C is considered today a low level language, but when it was released it was a high level language.
compared to C# or Java, you can say its low level, but C# & Java are just a higher abstract layer

same goes for win32, today it is considered systems programming, but when it was
released it was just an API ontop of windows NT, etc

eventually C# & Java will probably be considered low level, they are just layers ontop of other languages, etc like C is ontop of assembly, and
Java in ontop of C.

OOP was created to make programming easier(thinking in objects), etc
just remember the layers you are ontop of when u program

Share this post


Link to post
Share on other sites
Low-level is my bread and butter.

I've always loved knowing and wondering what was going on underneath all these symbolic English words on my text editors, IDE programs, etc, such as "include this", "load that", "call this", "return this".

Higher-level programming means simply writing instructions in a language that is not directly, or close to being directly, executable instructions from a processor for a specific instruction set architecture(C is not really "low-level" as Assembly languages are).

Lower-level programming is writing instructions that can more closely be executed directly by the processor(Assembly or machine code).

Assembly on a specific architecture is almost the lowest you can go without almost completely sacrificing readability. Binary code or machine code is the lowest-level execution done in general, but even that can get one step lower: microcode(although useless in almost every case for developers, and always pre-coded by hardware engineers basically).

It's almost impossible to do much of anything with machine code directly because it's extremely difficult to maintain, and you'd have to literally enable yourself to think along the lines of machine instructions for every miniscule instruction done by the processor.

Assembly is much more readable, but still very, very difficult for a newcomer to really grasp(I am still in the midst of learning Assembly for x64 after first mastering 8-bit Assembly from 6502 Assembly, which was used in Nintendo Entertainment System's console in 1985).

This is why higher-level languages get things done faster, because the abstraction from the processor is defeated using other tools and programs to "translate" the higher-level instructions into a directly executable format(on the machine code level, usually).

If you really want to go to low-level, it's a definite suggestion to start with lower bit-depth processors first(through a virtual machine or such).

Although low-level has lost its spark decades ago, it's still nothing more than amazing and useful information to know how it all works from the hardware itself.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement