High-level and Low-level languages.,
Members - Reputation: 172
Posted 30 October 2012 - 11:39 AM
Members - Reputation: 637
Posted 30 October 2012 - 11:43 AM
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, 30 October 2012 - 11:45 AM.
Members - Reputation: 551
Posted 30 October 2012 - 12:37 PM
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...
CEO & Lead Developer at ATCWARE™
"Project X-1"; a 100% managed, platform-agnostic game & simulation engine
Please visit our new forums and help us test them and break the ice!
Members - Reputation: 651
Posted 30 October 2012 - 01:01 PM
In C++ or Java for example, we can obviously know what's going on
but it's hard to understand the low level languages like assembly or machine code
[source lang="plain"]MOV AL, 1hMOV CL, 2hMOV DL, 3h10101001100101010010100[/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, 30 October 2012 - 01:16 PM.
Members - Reputation: 113
Posted 01 November 2012 - 12:32 PM
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
Members - Reputation: 287
Posted 01 November 2012 - 02:42 PM
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.