what is the (high - low )languages ?

[xray]

peace be with you

i want to know .. the low langauge and what's that mean and the example on it and the different between it and hight
thanks

[Paul M]

A high-level programming language is one that is much more user friendly. So the IDE would be easier to use A high level language would include Visual Basic.

A low-level programming language basically is something like ASM(assembly) that is more of a machine-orientated language.

[Slaine]

Some good stuff here:

http://en.wikipedia.org/wiki/Low-level_language
http://en.wikipedia.org/wiki/High-le...mming_language
http://en.wikipedia.org/wiki/Very_hi...mming_language

[szlamany]

CPU's only understand machine code. Everything that's written is somehow "driven" down to machine code.

Machine code would be 1GL - first generation language. Everything written in "instruction codes".

2GL would be an assembly language - it's really nothing more than machine code other than the fact that it's written in keywords instead of "instruction codes" - but still translated down to machine code for execution by the processor.

1GL and 2GL languages require knowledge of the CPU and it's allowed operators and management of the registers available.

3GL languages are what most of us here develop code with. These languages do not require that you have knowledge of the CPU and it's capabilities. Something like VB has a syntax that's reasonably common to many different "language vendors". The VB syntax is still reduced in some way to a machine code executable - as the CPU can still only understand those operators.

4GL languages are also possible. Usually these are home-grown efforts to minimize effort to produce results. IBM had a product called RPG (Report Program Generator) that allowed for production of report-like output without any programming (any 3GL programming that is). You can imagine that most reports have extremely common properties - print some columns of data - many a total here, a total there. Break and reset totals - eject the paper. These "operations" when put into a 4GL allow for quick production of reports. We have produced our own 4GL here that allows us to create "maintenance forms" for users to access data. All the textboxes and grids and functionality of the maintenance form are derived from a series of rules stored in the database and some SQL stored procedures. This is basically a 4GL.

SQL could be considered a 4GL - since the query itself is all that's written. The "engine" takes that query, opens a connection to the data - accesses that data and produces a result. Then you have T-SQL (or PL/SQL for the Oracle folks) which is basically dragging SQL back from 4GL down to 3GL and allowing you to have loops and variables and logic flow.

btw - all these distinctions are constantly blurred - and really just a matter of opinion - especially when you start considering all the possible languages that can be used today for producing results on a computer - HTML, JAVA, all kinds of scripting and markup languages...

[Shaggy Hiker]

I would add that each generation has tried to wrap some of the underlying code to a greater and greater extent. In ASM, the simple task of performing a loop is not so simple to write, and if it is not commented well, it can be a real chore to read. The C language is not very far above ASM, but a conditional is written in a way that most people can read, even if they can't always parse it well (If this). Since C is such a thin layer above ASM, it is quite easy to write ASM as part of C.

The C++ language added OO design onto C while retaining much of the low level capabilities and efficiencies. However, most languages above that have made the code even more readable. VB, with its If....Then....Else....End If structure, makes reading conditionals as close to english language as we can currently get, which makes it even easier for people to understand.

However, once you get into classes, with either C++, or VB.NET, there is no simple and obvious set of ASM that can be written for each line of code.

With C, most lines translate into one line of ASM per line of C. Conditionals and loops don't, but most lines are pretty close. The higher up you get, the more lines of ASM appear to get written per line of code. You could do all of that ASM instead of those lines of code, but the higher level languages remove the tedium and chance of error which comes from writing all that ASM.

[penagate]

Declarative languages are usually considered 4GL or 5GL - when you're not writing imperative code but rather defining the problem and constraints and letting the computer figure out how to fix it.