High Level Languages

1) high level language definition via google, also
a cross over between question 1 & 2, as well as
random article on high level languages for image processing.
2) should be answered somewhere up there (at least conceptually).
3) round about from #1
4) don't know.
cheers.

Thanks for the links stormrunner!

What i was thinking, is something like an extreamly heigh level languge (like lisp), compared to a low level language (C/asm).

What i was thinking about, is how a heigh level language would operate, when it gets extremely heigh.

From,
Nice coder

"high" is not really a term that lends itself to quantitative comparisons. That is, it's not always possible, given two languages, to say which is a "higher" language than the other.

Generally speaking, however, since high level languages are meant to express programs in a natural and human-readable format, natural language (simply telling the computer what to do) would be the apex.

BTW, apparently you haven't noticed how the word "high" is spelled.

How would natural language programming work?

Keep rendering the world, and doing physics calculation until the end of the game...?


Sorry for the spelling of high, i've been spending too much time with my chatbot (who thinks that heigh is high, because i mistyped it the first time, and it auto-corrects spelling errors. so it always spells it heigh!).

From,
Nice coder

You can change the title of your post by editing the original message.

Answer to the forth question:

In star trek,

"Computer, set the course to 324."
"Roger."

I guess that is how hight can it go.

rtsmp.highlevellanguage
G(RTS|MP)

// G() = creates a new game
// RTS = Real-Time Strategy
// MP = Multi-Player

Heheh funny, yes? No? Yes? No?

No serious, I was taught that op-languages like ASM are low-level and keyword-languages like C/C++/Java are high-level.

I've also spent a bit of time wondering how high high level languages can get.

Currently all programming languages have to be unambiguous which limits how high level they can be. Perhaps in the future through advances in AI and data mining techniques people will be able to use tools to create applications from statements such as "I need a text editor with features X, Y and Z". This tool could be considered as a very high level programming language.

Sure, the application developed may not suit your exact needs, but you would probably be close. It could be refined further through an interactive dialog.

I don't see this happening any time soon, but I don't think its impossible.

Quote:

Original post by SmooJ I've also spent a bit of time wondering how high high level languages can get. Currently all programming languages have to be unambiguous which limits how high level they can be.

There is well defined fuzzy logic which helps expert systems answer ambiguous questions.

How much Lisp do you know?

I agree with Sneftel saying that it's not always possible which language is higher than another, but we can consider that RAD tools are higher than high level languages.

Quote:

Original post by Nice Coder How would natural language programming work?

Put simple: It doesn't work.

Of interest: Language Oriented Programming. I was considering starting a thread to discuss it, but it fits well in this one. LtU readers will likely have seen it already.

I think the article is hopeful and has some nice ideas but the problems with LOP outweight their proposed benefits. i.e. most people are rubbish at language design.

It's all about abstractions. A prog. lang. will abstract something whether it be hardware or a lower lang. How high a lang. can go is determined by the problem space you're working in. Sometimes you need to travel between many abstraction layers to do your work. So there can be more than one abstract layer you're dealing with. Forgetting about the hw for now, the sw abstract layers will be dictated by the nature of your application or program you're making. There are certain mechanisms you need at low abstraction and some can be highly abstracted away. It is this constant traveling between abstractions that causes problems for the programmer. But generally speaking, it's easier for the programmer when he doesn't have to deal with the "efficiency" issue and that will allow him to work at a better abstraction suited for the programmer rather than the machine. How high above that is determined by the complexity and mechanics of your featureset.

Unless you happen to have a good optimizing compiler [grin].

What would a fifth generation lagnauge be like?

Form,
Nice coder

See Wikipedia:

First Generation Languages, etc.

Quote:

Original post by Nice Coder What is a high level language?

It depends.

Some define a high level language as simply a language with a high level of abstraction over the machine. In this regard, declarative languages like Prolog or SQL are the highest level languages possible: a statement in Prolog or SQL is almost unrelated to the processing performed. Note that with this definition, a natural language may be high level or low level: anyone can translate an assembly language program directly into prose.

I like to make a distinction upon the basis of how much attention a language requires you to pay to the irrelevant. A low-level language requires you to pay much attention to the irrelevant, whilst a high-level language does. The "irrelevant" is anything that isn't a solution to the problem.

It should be obvious that this definition is highly relative. For non-trivial applications C++ requires careful attention to memory managment, and that's almost always irrelevant (and thus C++ is low-level), except when the problem is that you need a memory manager (and thus C++ is high-level).

Quote:

How are high level languages made?

The same way other languages are made. Compilers and linkers.

Quote:

What makes them high level languages?

As above.

Quote:

How high can a language go?

This also depends.

There might be a logical limit to how abstracted from the machine a language can become.

There is definately a logical limit to how much irrelevance can be eliminated from a language -- the most relevant possible program for any problem is always going to be "do it".

Perhaps the truth of it is that there is a limit as to how high-level a general purpose a language can be. In most "very high-level" languages, you don't need to pay attention to the irrelevant, but that also constrains what can be done with the language. SQL is well-suited for querying relational databases, but not making rasterisers. Prolog is well-suited for querying predicate-based knowledgebases, but not for physical simulation.

I'd say that the issue is that there comes a certain point where abstractions become too generalised to be useful. When one reaches that point, programming consists of creating specialised compositions of abstractions, rather than additional abstractions.

So your program becomes a diamond: abstractions built up from a specialised core -- the language, and then specialisations narrowing in on a specialised solution -- the program you want to write. In 'metalanguages' like Lisp, the lower half of the diamond consists of defining an increasingly domain-specific language, and the upper half consists of conventional programs written in that language. Arguably, C++ is the same, but one creates a "language of objects" rather than a "language of syntax".

Quote:

Original post by flangazor Of interest: Language Oriented Programming. I was considering starting a thread to discuss it, but it fits well in this one. LtU readers will likely have seen it already.

Yawn. He's just reinvented Lisp. And then he has the audacity to describe Lisp as "hard to extend". Making mini-languages is how you program in Lisp.

Quote:

Original post by Anonymous Poster The simple answer would be: visual. It can be argued that VB is a 5GL, coz of the way you visually create forms and link them together via a workbench of some kind.

I don't think that can be argued. Unless you've already defined a 5GL as being visual. But then that's a circular argument.

Quote:

Then again, one could argue that stored procedures in SQL could be considered 5GL, but it wouldn't be a complete language. You still need the 4GL parts of SQL to call your procedures.

How would one argue that?

Quote:

As a rule of thumb I found this: http://www.computerhope.com/jargon/num/1gl.htm It's as good as any classification I could find. ;P

I disagree. I could create a "visual tool" for assembly programming. Doesn't make assembly a fifth-level language.

I don't think that "visual languages" are a higher-level language. I think they are a different kind of language, designed for a different purpose, they would have levels of their own.

For example, with Visual Basic (last time I used it) I have to make sure my controls are aligned properly manually. If I want the form to correctly handle being resized, I have to write code to do that my self. On the other hand, QtDesigner and Glade (designers for Qt (duh) and GTK, respectively) can automatically manage the layout of controls. Usually, the layout of controls is irrelevant to me. I just want to know that the controls will be visible. So I think that the "visual language" of QtDesigner/Glade is higher-level than that of VB.

You can use this approach for other (arguably) non-programming languages. PostScript is an example of low-level document formatting languages -- they contain low-level rendering instructions that map almost directly to hardware operations. HTML is an example of a high-level formatting language. HTML is akin to C++ -- it's high-level, but also allows the writer to 'escape' to a lower level and explicitly specify layout using CSS. Another document formatting language, TeX, is akin to Lisp -- it's low-level at the bottom, and one uses macros to build domain-specific languages on top, such as LaTeX, which is more abstract than HTML. The same applies to XML/SGML, upon which one can built, for example, DocBook.

Perhaps this could be described as a purely visual language.

As for the rest, I like Mayrel's definition of high-level.

The groups:

comp.lang.ml

comp.lang.functional

Usually have good discussions to follow (with references), which delve into all aspects of programming languages (functional, imperative, logic, you name it). There are also innumerable papers available via google or citeseer, although you'll have to specify your actual area of interest (implementation? theory? etc.)

Quote:

Original post by Mayrel For example, with Visual Basic (last time I used it) I have to make sure my controls are aligned properly manually. If I want the form to correctly handle being resized, I have to write code to do that my self...

I think I heard that the next version of Visual Studio will have that in the form designer.