Ruby a "4th generation language"? Credible sources?

I’ve noticed that Wikipedia says that “C#, Java” are 3’rd generation
languages[1] and “Perl, PHP, Python, Ruby” are 4’th generation
languages[2].

My question is:

Are there any credible sources that categorize these languages in this
way?

[1] http://en.wikipedia.org/wiki/Third-generation_programming_language
[2] http://en.wikipedia.org/wiki/Fourth-generation_programming_language

On Jul 31, 2011, at 3:50 AM, Albert S. wrote:

[2] http://en.wikipedia.org/wiki/Fourth-generation_programming_language
It’s Wikipedia, and being a community driven content site people will
still say things without citing sources. That’s why we have good ole
[citation needed]. Honestly though, will people throw Ruby out as a
language choice because of an article Wikipedia has? If so does the Ruby
community really want someone that makes such narrow minded decisions? I
honestly believe that the decision to work with a language is determined
by more valuable conditions such as documentation, community activity,
popular uses (Rails), and how easy it is for the user to work with.

TLDR; I call BS

Regards,
Chris W.
Twitter: http://twitter.com/cwgem

On Sun, Jul 31, 2011 at 07:50:44PM +0900, Albert S. wrote:

[2] http://en.wikipedia.org/wiki/Fourth-generation_programming_language
Problem solved: Perl, PHP, Python, and Ruby have been removed from the
list of Web development 4GLs in the 4GL article. I probably wouldn’t
re-edit PHP out of the list if it reappeared, because it strikes me as a
bit of a borderline case, but Perl, Python, and Ruby definitely do not
belong there.

RSpec might, though.

The Wikipedia articles are spurious.

I think this is closer to the truth:

http://en.wikipedia.org/wiki/Talk:Second-generation_programming_language

Third generation came into mark the first languages a level above
assembler. Fourth generation was applied to things like Focus which
dealt with typical DP tasks by removing some of the chores, particularly
empty datasets or starts/ends of datasets. That theme would lead you to
say SQL or say PL/SQL were 4GL but of course people now expect more of a
programming language so would reject these as ‘languages’.

Things moved away from this pattern. We seemed to revert to lower level
languages like C but added in all sorts of powerful features and
libraries. Ruby with its iterators deals with some things in a way 4GLs
did.

So while the terminology is obsolete, what is interesting is why the
author wanted to distinguish Ruby from C#. As I recall, 4GLs were
interpreted and thus capable of dynamic programming. Perhaps that’s what
he/she was getting at.

On Mon, Aug 01, 2011 at 04:24:43PM +0900, Mike S. wrote:

I think this is closer to the truth:

http://en.wikipedia.org/wiki/Talk:Second-generation_programming_language

In my experience, the language “generation” talk is (as noted early on
that page) basically marketing. People use it to try to say their
language is better than yours. People who are serious about software
development and language design tend to refer to languages as being more
or less “high-level” or “abstracted”, or as being more or less “domain
specific”, while people who are more serious about selling you on an
idea
will sometimes refer to a language as a “4GL” as if that makes it good
somehow.

From what I’ve seen, when someone who actually knows what (s)he’s doing
and cares about getting something done uses the term “4GL”, the term is
used in a sort of sarcastic or derogatory way to mean “not a real
programming language”. Suffice to say that there is a lot of skepticism
out there about the generational jargon for language classification.

Your mileage may vary.

Third generation came into mark the first languages a level above
assembler. Fourth generation was applied to things like Focus which
dealt with typical DP tasks by removing some of the chores,
particularly empty datasets or starts/ends of datasets. That theme
would lead you to say SQL or say PL/SQL were 4GL but of course people
now expect more of a programming language so would reject these as
‘languages’.

More of a language than PL/SQL . . . ? You’re aware that PL/SQL is
actually a Turing-complete programming language – right?

Granted, I wouldn’t want to use it for general purpose programming, but
it is entirely capable of such (ab)use.

Of course, I seem to recall that the idea of third generation languages
as a term of jargon mostly arose as we approached the marketing hype
around upcoming so-called fourth generation languages. Businesses
started thinking about how to sell people on the idea of non-programmers
being able to do all of your programming, and eventually ended up with
what they called 4GLs, which actually programmers looked at with severe
suspicion because of the way they tended to give people with no skill
the
ability to create something with no value (in their view, at least)
while
still effectively devaluing the contributions of software developers in
the eyes of middle managers. I think 3GL has mostly arisen as a term
used to denigrate anything in common usage that is not a 4GL according
to
the marketing geniuses trying to sell you a drag-and-drop automation
system.

Back when languages like C and its descendants started to appear, I
think
everyone basically just called them “high level languages”, and not
“third generation languages”. Maybe all of this is just my perception,
based on the people with whom I interacted at the time and the reading
that I did over the years. I suppose I might have completely missed a
lot of people using the term 3GL years ago, before the rise of 4GLs as
products.

Perhaps a little ironically, I have actually seen a 4GL that might
actually provide some of what it promises as a way to make it possible
for non-programmers to do some programming – some, I say. I speak of
Google’s Android App Inventor. It has some limitations that make it
unsuitable for some purposes, and unenticing to me as a developer, but
it
really does allow some pretty arbitrary software development goals to be
achieved by someone who is not familiar, or comfortable, with
traditional
programming tasks involving the work of writing source code.

Things moved away from this pattern. We seemed to revert to lower level
languages like C but added in all sorts of powerful features and
libraries. Ruby with its iterators deals with some things in a way 4GLs
did.

So while the terminology is obsolete, what is interesting is why the
author wanted to distinguish Ruby from C#. As I recall, 4GLs were
interpreted and thus capable of dynamic programming. Perhaps that’s what
he/she was getting at.

That’s a very strange way to distinguish between a so-called 3GL and a
so-called 4GL, and seems to disagree with every other means of
differentiating between them that I’ve ever encountered. Interestingly,
it would make Objective Caml both a 3GL and a 4GL, depending on how you
use it, as well as something in between – because the “official”
implementation of OCaml comes with a compiler, a bytecode VM, an
interpreter, and even a REPL. How do you classify Common Lisp using
such
criteria – a language available in a plethora of implementations,
including compilers at one extreme and interpreters at the other?

How do bytecode VMs fit into this system of categorization anyway? Ruby
is very heavily moving toward VMs and away from basic interpreters,
including the new reference implementation for 1.9.x, Rubinius, and so
on. Does that make it no longer suitable for identification as a 4GL
according to the criteria of someone basing categorization on
interpreter
vs. compiler implementations?

On Mon, Aug 1, 2011 at 4:51 PM, Chad P. [email protected] wrote:

actually a Turing-complete programming language – right?
Actually, PL/SQL is a pretty good procedural language with a decent
module system. Unfortunately it’s abused even in the domain where it
resides (Oracle database) but the blame cannot be put on the language.

It’s also noteworthy that SQL is not a programming language at all.
It’s a declarative language used to describe tuples and sets of
tuples. Full story @ http://en.wikipedia.org/wiki/Sql

Kind regards

robert

Chad P. wrote in post #1014196:

That’s a very strange way to distinguish between a so-called 3GL and a
so-called 4GL, and seems to disagree with every other means of
differentiating between them that I’ve ever encountered.

Well I agree. So what’s your theory? Why did someone see Java as a 3GL
yet Ruby as a 4GL?

On Tue, Aug 02, 2011 at 05:47:35AM +0900, Mike S. wrote:

Chad P. wrote in post #1014196:

That’s a very strange way to distinguish between a so-called 3GL and
a so-called 4GL, and seems to disagree with every other means of
differentiating between them that I’ve ever encountered.

Well I agree. So what’s your theory? Why did someone see Java as a 3GL
yet Ruby as a 4GL?

Good question. Probably some kind of anti-“scripting” language bigotry,
I guess. I didn’t say that’s necessarily not how the guy decided to
differentiate between third and fourt generation languages. I just
think
that the fact it’s an interpreted language makes for some ridiculous
criteria, in and of itself.

On Tue, Aug 02, 2011 at 12:00:31AM +0900, Robert K. wrote:

More of a language than PL/SQL . . . ? You’re aware that PL/SQL is
actually a Turing-complete programming language – right?

Actually, PL/SQL is a pretty good procedural language with a decent
module system. Unfortunately it’s abused even in the domain where it
resides (Oracle database) but the blame cannot be put on the language.

Yeah, that was kinda my point.

It’s also noteworthy that SQL is not a programming language at all.
It’s a declarative language used to describe tuples and sets of
tuples. Full story @ http://en.wikipedia.org/wiki/Sql

That’s true of SQL itself. It’s not true of PL/SQL, which is a lot more
than just SQL.

Roger P. wrote in post #1019851:

We tell it to read a file
and it spits out Fortran
Probably a useful way of looking at generations. A 4GL builds on 3GL
contructs, taking away the need for you to write predictable things.

4GLs were of their time. That time has passed.

Write one today and Rubyists would call is a DSL, not being reflective
enough to see all languages are domain specific to varying degrees.

4GLs were good. Apart from keeping me in beer for more than decade, they
encouraged you to do simple things in preference to flashy things. Most
things in business are open to simple solutions, and you write things
faster and with less errors. Ruby is prone to over-sophistication, with
certain clever people like David Heinemeier H. unable to resist the
temptation.

I’ve noticed that Wikipedia says that “C#, Java” are 3’rd generation
languages[1] and “Perl, PHP, Python, Ruby” are 4’th generation
languages[2].

I was once chatting with a fellow at church who programs mainframes. He
said “oh yeah we program in a 4GL language. We tell it to read a file
and it spits out the Fortran necessary to do all the reading and
parsing.”

Which immediately made me think of Ruby’s
File.read

So…just sharing it because it was funny at the time :slight_smile:
-r

On Mon, Sep 5, 2011 at 2:13 PM, Mike S. [email protected]
wrote:

4GLs were good. Apart from keeping me in beer for more than decade, they
encouraged you to do simple things in preference to flashy things. Most
things in business are open to simple solutions, and you write things
faster and with less errors. Ruby is prone to over-sophistication, with
certain clever people like David Heinemeier H. unable to resist the
temptation.

Can you clarify this? I have a suspicion that what you are calling
“over-sophistication” is just one way of talking about the implicit
“magic”
of convention over configuration. If you know the conventions, then is
Rails
(What I assume you are referring to when you criticize DHH) actually
overly
sophisticated? And if you don’t know the conventions, then isn’t the
problem
ignorance rather than sophistication?

A follow up question. If you are referring to more than convention over
configuration, then is it actually overly sophisticated, or is it just a
set
of techniques that weren’t common and thus initially seemed
sophisticated,
until people became more familiar with them? For example, design
patterns
seem overly sophisticated when you are unfamiliar with them. But after
you
learn them, they aren’t so confusing, and they allow you to solve some
complex problems.

True - once you’ve become sophisticated, you might as well enjoy it.

The thing is the web sites I’ve been involved in over the last few years
are all ultra-simple (partly to lead the customer to effortless
purchase) - much the same as, say, call centre apps I used to program 30
years ago. Yet Rails is vastly more baffling than Focus - a thousand
times more powerful but I’m not sure that’s ever so useful.

We used to do rapid changes to systems supporting hundreds of people
selling thousands of policies an hour running a mainframe to the max yet
not a single person felt they were missing a lambda.