Where Should all the 4th Gens Go?

ARSDeveloperGuy writes "Fourth generation languages are cool, but there seems to be little to no effort being spent to standardize them. The current state is commercialized pseudo-languages are created to allow vertical apps to be expanded. (ARS Remedy, Siebel, Oracle JDeveloper) The concepts of a form, field, and workflow can be standardized, and when you look at many of these languages they aren't terribly different. Why don't we create a standard and start writing "workflow converters" for these powerful languages? That would allow conversions to happen more readily, maybe even to an open source offering like OpenSourceCRM."

Re:my house

[Gumph]

tsk, you true to crack a joke and look what happens you get modded as a troll.
the worst it should have been was off-topic, I am not trying to incite people here, just spread a bit of mirth.

to paraphrase the Kurgan - "Mods! no sense of Humour."

the point of higher lvl languages

[telecsan]

Isn't part of the point of the 4th & higher gen languages that they are customized to a specific application. TFA gives MATLAB and Mathcad as examples. I don't think a 'generic' 4th lvl language would be helpful or even possible.

Re:the point of higher lvl languages

[Dan Ost]

You're exactly right. People who think that there should be standardization
of 4th generation languages are missing the point. 3rd generation languages
are general purpose. 4th generation languages are designed with specific
problem areas in mind and so adopt syntax and paradigms that are convenient
to that problem space.

Re:the point of higher lvl languages

[AuMatar]

One buzzword is newer.

Re:the point of higher lvl languages

[Anonymous Coward]

Hm. Lisp philosophy: Lisp is a language for writing languages. A good lisp program extends the lisp language vocabulary in an application-specific way.

The "standardisation" of 4th gen languages is indeed futile, as they are by definition domain-specific. What you can standardise howevert is the best way to integrate a bunch of domain-specific languages together. Then you get Lisp [cliki.net]: around since 60s, and constantly evolving to the present day.

Or, given the amount of NIH the computing world displays, we'll probably see some misbegotten lisp clone only with perverse XML instead of straightforward sexp syntax. And it will be hailed as a Great New Thing, similar to the way compsci researchers get funding for AI/KR by rehashing in XML+Java/C# the oodles of toy 20-year-old programs written in Lisp before the AI Winter.

Re:the point of higher lvl languages

[Anonymous Coward]

Maybe it'll be a lisp that supports lightweight processes, unicode, and has a compatible windows port that costs less than $10,000 per seat.

Oh hey, hello MzScheme.

Lisp is hardly one to talk about NIH. Their philosophy is "everything was invented in Lisp first, so actually implementing and releasing whatever you're talking about is left for plebians who don't understand the elegance of lisp"

Re:the point of higher lvl languages

[joto]

Maybe it'll be a lisp that supports lightweight processes, unicode, and has a compatible windows port that costs less than $10,000 per seat.

Oh hey, hello MzScheme.

Of which the only limitations of note, are that it is slow. As slow as e.g. Perl or Python. Still very nice, though...

Lisp is hardly one to talk about NIH. Their philosophy is "everything was invented in Lisp first, so actually implementing and releasing whatever you're talking about is left for plebians who don't understand the elegance

Re:the point of higher lvl languages

[ScrewMaster]

I'm considering writing a domain-specific derivative of Lisp, called "Bogart".

Re:the point of higher lvl languages

[2short]

"Lisp is a language for writing languages"

That sums it up pretty well. Lisp is a great language for writing languages, and a fabulous language for talking about algorithms. So if you want to examine and discuss the theory behind languages and algorithms, I'd definitely recomend Lisp.

If you don't care about writing languages or theoretical discussion, and just want a good language for writing actual software, I'd reccomend C++, but even the much-hated Java will probably serve you better than Lisp.

Howabout the dump?

[mugnyte]

...just kidding

But seriously...4GL's that survive today have big followings, and are just another market. Who's to say that platforms must be consolidated and homogenized?

Even though they all strive to complete the same goals (and all try to balance generalization, approachability and brand) - there isn't anything wrong with having them around, to me.

Think of all the 4GLs and embedded languages that could be replaced with a standard ...but then think about all the "standard" tools. Um, how many "standa

Never going to happen!

[FriedTurkey]

As much as I would like to see it, fourth generation languages are never going to standardize. Most are derivatives of a standard well known languages like C or Java. Teaching yourself the 4thGen language is never that hard. Most of the vendors have 10+ years in a language that would break existing code on a upgrade. Plus it would make it easier for a migration to a competitor.

I don't believe OpenSourceCRM has a 4th generation language. All of the open source CRM packages I have researched are really just collections of code without any application level programming abilities. Customizations would involve changing the low level source. I guess open source packages feel there is no need to separate the functional programming from technical programming. An application server that runs the same business code for a web page as an integration is a must. Some companies are never going to take a CRM application seriously if a customization involves changing a PHP file. It may work great in a small environment but it will never replace Siebel or OracleCRM unless it packaged with a developer application that generates "forms/page" and compiles 4th generation code.

Benefits?

[Umbral Blot]

I don't see the advantages to standardizing these languages. One of the things that makes them useful is that they are designed to perform a smallish set of tasks efficiently and with little effort for the programmer. Standardizing them seems like it would move them all away from their problem domains making them less useful.

MathML

[pfafrich]

Most posts here seem to be down on this idea. In the maths world at least there does seem to be quite a push for interoperability of the many maths 4GL's Mathematica, Maple, Matlab. Theres a thing called MathML which is specifically designed so that there is some common way that these different platforms can communicate. In theory you can write some code in Mathematica, convert it to MathML, send it to a colegue using Maple and they can convert it to Maple code and run it.

Maybe mathematics is a special domain in the the 4GL's we are seeing are really trying to represent the same 7GL (i.e. maths notation), so the problem is intrinsically easy.

I'm getting kind of worried by the conservatism of the Slashdot crew. Any new idea coming along (database yesterday, 4GL's today) seems to get shot down. Are we going to actually see new ideas coming from the opensource movement, or is it just going to be limited to reimplementing existing programs?

Re:MathML

[jbolden]

Maple and Mathematica are math languages in which you have a bunch of products which do almost exactly the same thing being used by people doing almost exactly the same thing. This is one of the best possible cases. Now consider say TeX and Mathematica. Those are 4GLs, the common syntax would end up looking a great deal like scientific word for windows. But Mathematica and Maple use lazy evaluation throw in say Mathcad which uses soon as possible evaluation and you quickly see you wouldn't want to run the same code everywhere. That is, even where it is easy to do it may not be useful.

Lets branch a little further. TeX assumes you know a lot about the subject matter but not a lot about typesetting which is very unusual for design languages. Things like compuset assume the opposite; that is the information is simple but the user knows all about fonts, kerning, layout, paper stocks.... How are we going to combine those two totally opposite user emphasis? Oh and another importat difference compuset is usually designed to run in batch mode, TeX is usually designed for one of a kind documents. So we want different kinds of error messages (compuset: record 23454 violates parameter ARDS, record skipped, vs. TeX page 14 macro ARDS does not accept floating point numbers [c]ontinue [e]dit....?

This idea got shot down because its a bad idea. Most ideas are bad ideas and thus most ideas are going to get shot down. That's not a bad thing. The cheapest place to kill a bad idea is in the "I have an idea" stage before any labor gets spent on it. The good ideas are not generally the grand schemes but very specialized one off solution that just seems to work for related things and then things related to that and then a pretty broad range of problems.... The ones invented this year are unlikely to be noticed by the broad community for 5 years or more.

Re:MathML

[Forbman]

Math already has a standard meatworld/cellulose/chalkboard representation, familiar to just about everyone.

MathML simply allows one to simulate that kind of data interchange between computers, applications and people. The underlying message, though, is the same.

Having worked a bit with some 4GL-ish apps (PeopleSoft, some SAP), while they may share the visible results and the same ends, at the programmer/developer level both systems are about as different as LISP and APL.

Why bother?

[Bastian]

There's not much in FORTH to standardize, anyway.

push pop push pop push pop push pop push pop push pop

Re:Why bother?

[david duncan scott]

And as you probably know (but the great mass may not) Chuck Moore called it FORTH in part because FOURTH was too long for the original development system's filesystem.

The Whole Concept of 4GL is bogus

[fm6]

"Fourth Generation Language" is one of the those silly concepts that never caught on, but still survives, woefully distorted. The idea was that writing software by encoding procedures and algorithms was obsolete ("third generation language"), and needed to be replaced by languages that used more advanced paradigms.

The so-called 3GLs didn't get replaced by the so-called 4GLs, because the latter aren't superior languages in every respect -- they just do some things better. The most conspicuous area where 4GLs excel is database access. As a result, many people think 4GL means "database language", and apply it to 3GL languages like Delphi and Visual Basic that are widely used in database apps.

I guess the term "4GL" will be around forever, but it really isn't very useful. If you want to categorize languages in a meaningful way, use terms that describe how they actually work, like "imperative" (3GL, more or less) and "functional" (4GL, ditto).

Re:The Whole Concept of 4GL is bogus

[FriedTurkey]

A 4GL programming language is designed to run inside another program. 4GL languages do not replace 3GL languages but instead run inside of them.

When you say "database language", PL/SQL is a 4GL language. SQL is running inside of Oracle, a C++ application.

Visual Basic itself is 3GL. Visual Basic for Applications running inside of a Access file is 4GL.

There are grey areas but it really isn't that complicated.

Re:The Whole Concept of 4GL is bogus

[fm6]

A 4GL programming language is designed to run inside another program. 4GL languages do not replace 3GL languages but instead run inside of them.

That's they way 4GLs are currently used. But they were certainly not intended to be embedded languages. Look up anything written on the subject 20 years ago, and you'll see what I mean.

Generations of Language

[jd]

Computer languages are broken down in Computer Science to five generations and three flavours, which have nothing to do with how they are used, or even how they are implemented, but rather the level of complexity required to actually use the language.

• First Generation: Trivial Machine Code. (Processors capable of running Java, etc, natively run "non-trivial" machine code.)
  
• Second Generation: Assembly Language. This is the first generation in which actual compilation is required.
  
• Third Generation: Procedural Language. Support for basic code and data structures, but no encapsulation of combined code/data.
  
• Fourth Generation: Abstract Language. You tell the computer WHAT to do, not how to do it, allowing the computer to work out what is best, rather than having a rigid, pre-built solution. Some level of encapsulation is implicit.
  
• Fifth Generation: Intelligent Language. You describe the problem and let the computer derive the most implementable specification from that description. In theory, this maximises reuse, portability AND performance. In practice, nobody ever did get it right.
  

• Functional Design: Code and data are seperate. This allows for multiple bits of code to scan the same data very efficiently, but it also means that you can't guarantee that the code will understand the data correctly. C is Functional and anyone who has used pipes in DOS or Unix is familiar with the idea of rapid scanning.
  
• Object-Oriented Design: Code and data are linked, such that code can only operate on data it can provably process and is provably present and set to a valid state. Smalltalk is really the closest to a "pure" OO system out there.
  
• Object-Based Design: Any hybrid, in which data can be encapulated with code, but this is not a requirement. C++ is Opbject-Based, as is Java.
  

Anybody can embed anything in anything, if they really want. That is not a criteria for anything. For example, C will support embedded assembly, but neither C nor assembly are fourth-generation.

C is NOT functional

[csirac]

Admittedly, I'm an EE and not a Software person, but I've been working a lot with FPGA [fpga-faq.org] design and this involves the use of a few "functional" programming languages such as the Scheme-like confluence [confluent.org] Hardware Description Language (HDL).

ANSI and ISO C are imperative [wikipedia.org], sequential, PROCEDURAL [wikipedia.org] languages.

From my (possibly wrong) understanding, languages such as Haskell [haskell.org] (Wikipedia [wikipedia.org]) and Scheme [schemers.org] (Wikipedia [wikipedia.org]) are "functional".

These are so far from anything at all like C programming, Haskell in particular for some rea

Re:The Whole Concept of 4GL is bogus

[Forbman]

VB vs VBA is not a good example of 3gl vs 4gl...

The magic that is VBA has more to do with the application-specific library, DAO and ADO. You can do the same things in VB.

ProC or ESQL embedded in a C program is probably more akin to what PL/SQL or Transact-SQL are to their respective database engines, wrt 3gl vs 4gl.

If we're including ARS Remedy,

[suitepotato]

then they belong wherever the fantasy land is that the fifth, sixth, seventh, eighth, and so on generation languages are. As soon as I saw that named, I nearly fell over on my keyboard. ARS is not a 4GL, it's a tool of psychological torture more fiendish than making one listen to Abba records played backwards for eternity.

Come to think of it, when an AI language app writes its own language to communicate with humans all on its own, then we'll have a 4GL.

Interoperability is not desirable

[Frans Faase]

Commercial companies are not interested in interoperability, because it only makes it easier for their customers to switch another vendor. And although these languages may look similar, it still doens not mean that it is only a matter of syntax. And as a commercial company, you are not going to change the exact semantics of your language in order to make it interoperatble with the language used by others, and let all your customers do the conversion (which is never as trivial as it seems). Microsoft tried t

Re:Interoperability is not desirable

[ScrewMaster]

VCJaBv++a

Re:Interoperability is not desirable

[petermgreen]

afaict

j++/java suitable for the old microsoft vm can afaict be turned into .net bytecode without even having the source.

not sure about C++ i know visual C++ .net can compile ordinary C/C++ code but it crashes on reading an unitialised primitive (wtf)

i've heared vb was changed almost beyond recognition though.

...long time passing.

[Anonymous Coward]

sorry, couldn't resist.