What's the difference between high and low level prgramming?

[bras0782]

------------------
Athlon TB 800MHz
Abit KT7a-RAID
250W PSU, Enlight Case
512MB PC133 SDRAM
30.7GB IBM Deskstar 7200RPM
32MB Diamond Viper770 Riva TNT2
Yamaha 6416 CDRW (SCSI)
16x Pioneer 106s DVD-ROM
52x LG Electronics CDROM
SB Live! 1024
Creative FPS1000 Speakers

[hydrobond]

I don't know the exact difference but i can give you examples. Assembly is a low level language and C/C++ is a high level language. Hope this helped a little.

------------------
1.1Ghz Thunderbird - not overclocked
Asus A7V
256MB Micron RAM
2 Maxtor 7200 30GB - want to stripe :-) (the card is on it's way!)
1 Seagate 7200 30GB
Elsa Gladiac 64MB GeForce 2 Ultra
Sony E400 19"
Sound Blaster Live 5.1
Cambridge Sound Works 5.1
Yamaha 16/10/40
12x DVD
Iomega Zip 100
HP LaserJet 2200D (B&W)
Fan Bus (home made)
Window (home made)
Handles

[Nephalim]

Originally posted by hydrobond:
I don't know the exact difference but i can give you examples. Assembly is a low level language and C/C++ is a high level language. Hope this helped a little.

Assembly is a low level language because it is closer to what the processor actually understands(binary or machine code). C++ can actually be called a "mid" level language because it has features that are further from machine code, but also has features that are rather low level. An example of a high level code might be VB, Java or (if you consider it a coding languages) SQL.

Higher level languages seem to be more "English" like and low level languages seem to be more arithmetic like.

------------------
~ And that is my humble opinion.

When I was a boy I was told that anybody could become President. Now I'm beginning to believe it. - Clarence Darrow

The greatness of a woman’s power is measured in the size and amount of the balls she clutches in hand. -Me

"Tink"
1 GHz Tbird on A7V, 384MB PC133 RAM, Samsung 19" 900IFT, Radeon 64MB DDR VIVO, SB Live! MP3+, 42.9GB IBM HDD, Plexwriter 8/4/32, 3C905CTXM nic, Intellimouse Explorer

[rock]

In terms of "Generation":

Assembly is a 2GL (second generation - it's only 1 step removed from actual 0s and 1s). Instructions here are cryptic register manipulations.

FORTRAN, C, C++, etc. are all 3GL. They compile to native instructions and can access memory directly. Instructions here are your regular IF, FOR, math/array ops, etc.

PV-WAVE, IDL, MATLAB, etc. are 4GL. They compile usually just to byte code and are interpreted. Usually you cannot get to RAM. Instructions here usually include 3GL stuff in addition to high-level ones like "PLOT" and they're typically array-based.

There are 5GLs too, but these are usually a 4GL with some DB connections added in (even though the 4GLs I listed above all have DB connections too).

Not sure where scripting languages fall in this setup. Also, I was going to stick Java in with the 3GL, but it doesn't compile to native code: you need a JVM to interpret it (like a 4GL), but it really isn't a 4GL....

------------------
The price of freedom is high.

[bras0782]

So what category would VBA and SQL fall under?

------------------
Athlon TB 800MHz
Abit KT7a-RAID
250W PSU, Enlight Case
512MB PC133 SDRAM
30.7GB IBM Deskstar 7200RPM
32MB Diamond Viper770 Riva TNT2
Yamaha 6416 CDRW (SCSI)
16x Pioneer 106s DVD-ROM
52x LG Electronics CDROM
SB Live! 1024
Creative FPS1000 Speakers

[rock]

Originally posted by bras0782:
So what category would VBA and SQL fall under?

Good question. I've thought of VBA as pretty much a macro scripting language, but you can do some nice things with it. It's going to sit on top of Office, though. Same deal with SQL, it's going to be sitting on a DB and requires an interpreter. I guess I'd put these guys at about 3.5, but that's just a guess since I don't use either enough to have a great feel.

------------------
The price of freedom is high.

[DeadKen]

Originally posted by rock:
In terms of "Generation":

Assembly is a 2GL (second generation - it's only 1 step removed from actual 0s and 1s). Instructions here are cryptic register manipulations.

FORTRAN, C, C++, etc. are all 3GL. They compile to native instructions and can access memory directly. Instructions here are your regular IF, FOR, math/array ops, etc.

PV-WAVE, IDL, MATLAB, etc. are 4GL. They compile usually just to byte code and are interpreted. Usually you cannot get to RAM. Instructions here usually include 3GL stuff in addition to high-level ones like "PLOT" and they're typically array-based.

There are 5GLs too, but these are usually a 4GL with some DB connections added in (even though the 4GLs I listed above all have DB connections too).

Not sure where scripting languages fall in this setup. Also, I was going to stick Java in with the 3GL, but it doesn't compile to native code: you need a JVM to interpret it (like a 4GL), but it really isn't a 4GL....

I always thought this 3GL/4GL stuff was a load of non-sense.

More marketing then reality.

You pointed out the problem classifying Java, but remember P-Code? So Pascal was a 4GL which moved up to being a 3GL?




------------------
I want an OS, not a hobby...

[rock]

Originally posted by DeadKen:
I always thought this 3GL/4GL stuff was a load of non-sense.

More marketing then reality.

You pointed out the problem classifying Java, but remember P-Code? So Pascal was a 4GL which moved up to being a 3GL?

From what I recall of Pascal (er, this is back in high school on an Apple IIe), I wouldn't classify it as a 4GL.

The thing with 4GLs generally is they can be as powerful or as weak as you want them to be. The ones I listed could all be used either as a scripting language to do graphics or as a replacement to nearly any 3GL as a number crunching/GUI solution too. I agree that the terminology is just marketing mumbo-jumbo, but there's certainly a lot of different levels of programming.


------------------
The price of freedom is high.

[Mordaunt]

Programming at a low level means each line of code consists of an instruction followed by one or two operands. You are basically loading hexadecimal values into specific memory adresses or comparing two values and branching based on the outcome. Low level languages like assembly have no abstractions such as data types, objects, or lovely pre-built visual components for you to click and drag into your application.

[ksuohio]

It's somewhat like low level and high level management in a company. The low level guys are the micro managers over the company. They have direct visibilty to the structures of the company and see things work first hand. The high level management uses all of the lower level managers to complete a task. They don't typcially work with the fine details and their orders are general, but still can help complete a task. The same holds true for programming languages on computers.

Sorry if that wasn't detailed as to the difference, but I though I'd add my 5th grade explanation to it

------------------
-Athlon AMD XP 1600+
OC at 1524 mhz 145 fsb
-Abit KG7 - Raid
-512mb Registered DDR Ram
-GeForce3 Ti 200
OC at 220/500
-DVD
-Sony CDRW
-13 Gig IBM HD
-SoundBlaster 16 PCI
-Good 'Ole Dell Keyboard
-MS IntelliMouse
-19" Trinitron Monitor
-Home Audio/Video Speaker System
-RoadRunner Cable Internet
-Windows XP Pro

[bras0782]

Originally posted by ksuohio:
Sorry if that wasn't detailed as to the difference, but I though I'd add my 5th grade explanation to it

I feel like i'm at nursery all over again (I guess that's kindergarden for you non-brits)

Ok, some of the computation stuff we did in my degree included compiler languages which used stuff like PUSH, PULL, STACK, etc... to manipulate memory contents and carry out calculations. I guess that was low level programming. The stuff we used was very ancient, so maybe those procedures mentioned are outdated now.

------------------
Athlon TB 800MHz
Abit KT7a-RAID
250W PSU, Enlight Case
512MB PC133 SDRAM
30.7GB IBM Deskstar 7200RPM
32MB Diamond Viper770 Riva TNT2
Yamaha 6416 CDRW (SCSI)
16x Pioneer 106s DVD-ROM
52x LG Electronics CDROM
SB Live! 1024
Creative FPS1000 Speakers

[RetardedTimmy]

Originally posted by hydrobond:
I don't know the exact difference but i can give you examples. Assembly is a low level language and C/C++ is a high level language. Hope this helped a little.

the difference is the separation from hardware to software...the more the language directly preforms specific hardware operations...such as w/ hexidecimal/machine code...the lower level it is, because while it is generally MUCH more efficient, than say...java, it is much harder to write in because each little data movement requires a full line of code. Here is a lab i did this past semester in binary/hex (they're pretty much the same...hex is shorthand sorta for binary just in case u don't know...)
<<
0x3000
0x5260
0b0101010010100000
0x1270
0x1241
0x1270
0b0001011011101111
0b0001011011101111
0b0001011011100011
0b1001011011111111
0xf023
0x16ff
0b0001001000000001
0b0001010011000000
0b0000010000010000
0b0101000000100000
0b0000111000000100
0xf025
>>
i can't even remember what this lab did..but it is pretty much the lowest level of any language...as each instruction is performing and add or store function etc..and if you go up one more level you'll get machine code (full lab is wayyyyy to long to post..so here's a line)
<<
LEA R2, PAL ; Load .BLKW starting address to R2; this is
>>
This performs a LoadEffectiveAddress function on R2 and the label pal...this lab can check a users input to test if it is a palindrome...heh it seemed really difficult at the time...anyhow...next up may be 'fortran' or 'c'..i'm not sure..but java is even higher level than c or cpp because it is even harder/more separate than c++, because in c++ it is not THAT hard to convert stuff to machine code by hand..however in java, it's more obscure and thuse a whole different story...
also, a rule is the higher level a language, the less efficient it will be able to run, but the tradeoff for the loss in efficiency is convenience and thus it is easier to make functions that do EXACTLY what you want them to do (a wider variety..)

hope that helped ya...
Later
Tim

------------------
¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸ ¸.·´¯`·.¸¸.´|
.·············. |
·TheTuRb0 R1G · |
*·············* --------------------------. |
2 x 256mb PC150 CoRsAiR | |
*TEMP = Duron750
1.4ghz AMD ATHLON AxIa {AyHjA} | |
Abit KT7A-RAID | |
Thermalright SK6 w/ 7K Delta, 85w Peltier | |
2 x 40gb 7200rPm EiDE {QuAnTuM}{WD} | |
Lian-Li PC68 | |
MS Intellimouse Explorer {silver} | |
MS Natural Elite | |
------------------------------------------´ |
¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸ ¸.·´¯`·.¸¸.·´

[e_dawg]

Originally posted by rock:
Good question. I've thought of VBA as pretty much a macro scripting language, but you can do some nice things with it. It's going to sit on top of Office, though. Same deal with SQL, it's going to be sitting on a DB and requires an interpreter. I guess I'd put these guys at about 3.5, but that's just a guess since I don't use either enough to have a great feel.

VBA and SQL are not programming languages.

SQL is a Query Language, and is only used to retrieve/set/update/etc data in a database.
VBA is a scripting language... Most people don't put these in the generation levels, but I'd say that no scripting language is below 4...

My understanding of the GL system was that each level was built on the last... VB is a very good example of a 4GL to me -- it is completely written in a 3GL...

So, machine code = 1GL (since it is basically a language in and of itself), ASM = 2GL because it was written in machine code, C/C++ = 3GL because it was written in ASM, VB = 4GL because it was written in C++...

Simple as that... I have never even seen a 5GL... that would be so far removed that it would seem like it would get rather slow.

This, of course, has absolutely nothing to do with the programmer generation, which is currently transitioning from the first to the second generation -- and we are good -- we grew up with computers around us everywhere... Why shouldn't we know them better?

[This message has been edited by e_dawg (edited December 23, 2001).]

[TheCrazyFoo]

Keeping it simple,

Low Level requires knowing details about the processor (How it deals with I/O, its registers etc.) EX. Assembly and Machine code.

High Level is more like an algorithm. EX. C/C++ Pascal Perl.

I have also heard that some also classify Very High Level, doesnt require algorithms and memory managment as much as the High Level's do. EX. Prolog