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."

Comments

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

[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: 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"

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).

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 design and this involves the use of a few "functional" programming languages such as the Scheme-like confluence Hardware Description Language (HDL).

ANSI and ISO C are imperative, sequential, PROCEDURAL languages.

From my (possibly wrong) understanding, languages such as Haskell (Wikipedia) and Scheme (Wikipedia) are "functional".

These are so far from anything at all like C programming, Haskell in particular for some reason reminds me of that movie Event Horizon, but that's probably just my warped mind thinking irrelevant thoughts again...

I'm told that the Haskell course taught at my University is a source of great frustration to many programmer wannabes who can never get their head around the "functional" programming paradigm and are forever stuck in their Java ways.

So, if C is classed as "functional" in your books, what would Haskell be?