A rather informal (and imprecise) taxonomy of languages, where higher values of n
imply a more programmer-friendly/advanced/expressive language. (This has nothing to do with TuringCompleteness?
; most of the languages considered are TuringEquivalent
The big problem is, nobody precisely agrees as to what constitutes an NthGenerationLanguage
for a particular value of n
--it tends to reflect the biases of the author or the speaker.
definitions for various generations follows; notice that what one author may consider n
th generation, another may assign to generation n
(doesn't appear in many texts/taxonomies):
I thought lisp was the first functional programming language?
AFAIK, it was the first to be implemented as a working programming language; however, there were a number of program-planning notations, both procedural and functional, which were used for designing programs which would then be implemented in MachineLanguage
6th Generation (You mean Next
- StarTrekInterface? - "Computer. Tea, Earl Grey. Hot."
- ...and out comes pouring litres upon litres of Earl Grey. Except that he's made this mistake before (that would be the "Tea, Earl Grey" program). The modifier "Hot." is the program which includes the necessity of a cup (at an appropriate orientation), a specific amount of tea to be placed in the cup, at a specified temperature (specified separately from the cup's temperature).... Or did you actually think "Hot." was merely a required parameter?
- "Human, fetch me some motor oil. Earl Grey, warm."
If I say X is a HighLevelLanguage
, but Y is a higher-level language, does that mean that Y is a later generation?
Or are they completely orthogonal ideas?
It usually does not imply a later generation, but both are such poorly defined terms, and for ages have been used more for hype than for descriptive capability, that it's impossible to say anything really definitive about this.
Except that generations are nominally discrete whereas higher-level-ness might be continuous. But the Generation
Police aren't going to stop you from saying that language XYZ is Generation 4.31583759184.
Anyway, they're fuzzy terms. The descriptions and contents of the categories above are semi-arbitrary, not something widely agreed upon. And there are no 5th or higher level languages, as I said before but which has since been deleted. The term "generation" was overused and misused by the time of marketing hype of "fourth generation", and the famous Japanese Fifth Generation project (based in part on Prolog, which generation was that?) was pretty much the final nail in the coffin.
The "generation" terminology made more sense, at first, where it originated: hardware. 1st gen, vacuum tubes. 2nd gen, transistors. 3rd gen, ICs!!! No 4th gen, we're still using ICs, but by then 3rd/4th/5th generation sounded futuristic, so marketing got involved. You know how it goes.
So, where does a BasicLanguage go in all of this?
was strongly inspired by, and shares semantics with, FortranLanguage
. Therefore, it categorizes no later than a 2nd-generation language. Modern dialects implement 3rd-generation features, however, make it perhaps one of the most successful cross-generation languages. The other that comes to mind is LispLanguage
And there are no 5th or higher level languages, as I said before but which has since been deleted.
will automatically resize arrays for you to fit more data. Plenty of languages are garbage collected. Someone should look into using this more widely. For instance, extending it to user-defined functions. In theory, if one were to give each primitive function a set of prerequisites, then it would be easy to construct prerequisites for user-defined functions. It's a bit delicate, but it seems feasible.
P.S. I'm not sure if this makes scripting languages 6th-generation.
Guys, guys, compromise. 5.5th generation ;-)
Where would Zork's input language fit into this? OK, so it's not exactly a programming language,
but it is conceivable that the technology used for it could be applied to creating a programming language.
I've never felt it right to call languages like 'C' "high level", and putting them 'above' the "high level" block in that image just seems wrong. I guess that's relative to where you've been standing in the language spectrum.
Look carefully at the diagram again: you'll find that C, et. al. are
fused with the "high level" block -- they aren't above it, they're illustrations
Perhaps you find some significance in that... not that you can actually say it's true of C in the image (FORTRAN, perhaps. Are you nuts? You consider Fortran but not C?
Uh... it seems you misread - the context of the statement to which you responded is, explicitly, "the image"
. You seem to have read it as a statement of something more general.). To me, I still see "C" sitting above "High-Level Language". In the vast spectrum of high-level languages, compared to such things as Prolog and SQL and VRML and PovRay
and Smalltalk, methinks C should almost be 'fused with' Assembly.
Finally, there is no argument that C is higher in abstraction level than pure assembly. The diagram is unequivocally correct in both local and global scopes of concern.
- SQL, VRML, PovRay, and InformLanguage are all domain-specific languages (but very High Level nonetheless). Prolog would serve as the only representative in your list which isn't a domain specific language, but which is used as one (usually, you'll find stripped-down Prolog-like cores serving as type inferencers for even more general purpose, yet decidedly high-level, languages like Haskell). (I assume you consider all forms of AutomatedTheoremProving to be "Prolog-like"?)
Also, remember when this image was constructed, or the sources it was taken from. Odds are likely, this picture is half as old as you are; times have changed, and languages of tomorrow will make even Haskell look like it's "fused with assembly language" by comparison, I'm sure. So let's cut the image some slack, eh?
- There is a spectrum among assembly languages, to a degree that 'pure assembly' really lacks a clear definition... unless what you mean by 'pure assembly' is a direct correspondence to machine code. I agree that C is higher in abstraction than a direct correspondence to machine code. But I've never even worked with an Assembly language that didn't at least support labels, constant definitions, and simple constant expressions. You ever hear of typed assembly or work with assembly variants with a TuringComplete macro system? I'm not certain that "there is no argument" here, though you could make a good case for C (especially its automated parameter management - register allocation, stack cleanup, etc.). Regardless, arguing that C is higher in abstraction than 'pure assembly' doesn't lead to the conclusion that the diagram is correct. Following that argument only leads to the logical conclusion that C should be sitting above "Assembly", not above "High-Level Languages".
- Besides, If "there is no argument" asserting "that C is higher in abstraction level than pure assembly", then how can you conclude the diagram correct. (Sorry, I couldn't pass up the obvious equivocation on "there is no argument", especially with you invoking words like "unequivocally". ;-)
One interesting fact about the Internet is that it, unlike print media, can update between viewings. Thus, if the linked image is half as old as me, then it's had since before the Internet boom to update the associated website to better reflect what people today call "High Level Languages".