[net.lang] Language popularity

donn@hp-dcd.UUCP (11/27/83)

#R:fortune:-182500:hp-dcd:24200002:000:497
hp-dcd!donn    Nov 25 10:24:00 1983

Re:
There are more programs written in Fortran...
There are more lines of code written in COBOL...
(Given the nature of the two languages, both could be true...)

(Quite) a few years ago I heard a statement like that only it went:

	There are more programs in RPG than any other language[sic].

	([sic] on the word "language" because its not clear that RPG
	is a language, its just used line one (sort of)).

	I sincerely hope its no longer true, if it ever was.

Donn Terry
...hplabs!hp-dcd!donn

whm@arizona.UUCP (Bill Mitchell) (12/13/83)

	From: andree@uokvax.UUCP
	Newsgroups: net.lang.c
	Subject: Re: RE: Re: great quote about the 'C' la - (nf)
	Date: Sat, 10-Dec-83 20:50:38 MST
	
	...
	
	Final note: Horrowitz (sp?) gave three rules for having a succesfull
	(i.e., popular) language:
	
		1) Write a good, clear book describing the language. The
			emphasis is on writing code, not exact definitions.
		2) Write a compiler for it that at least generates code.
		3) Sell the compiler incredibly cheaply. Better yet, give it
			away.

It seems that Horowitz has missed the most important point: there must
be some need for the language.  There are certainly hundreds of "major"
languages that meet points 2 and 3, and many of those have adequate
documentation available.  However, if a language is going to be successful,
it must fill a need that isn't met by available languages.  If a language
very similar to C, but with some of the blemishes removed, was introduced
today, would it be very popular?  I doubt it.

Programmers need to be motivated to move from one language to another.
Personally, I find many of the new languages to be interesting, but before
I'm going to switch from one language to another, I'm going to need a good
reason.  It appears that many of the popular languages today gained
acceptance because they could do things significantly better than other
languages available at the time of their introduction.  Consider this:
of the languages that are in widespread use today, how many of them were
drastically different from other languages available at the time of their
appearance?  Think about FORTRAN, Lisp, COBOL, APL, C; they were all
departures from what was generally available.  Note also that in many ways,
the new aspects of the languages arose from needs that weren't being met.

So, I propose a new rule:
	The language must fill a niche in the environment it is designed
	 for, and it must be able to displace competitors for that niche.

					Bill Mitchell
					whm.arizona@rand-relay
					{kpno,mcnc,utah-cs}!arizona!whm

andyb@dartvax.UUCP (Andy Behrens) (12/17/83)

>   However, if a language is going to be successful,
>   it must fill a need that isn't met by available languages....  
>   
>   Of the languages that are in widespread use today, how many of them were
>   drastically different from other languages available at the time of their
>   appearance?  Think about FORTRAN, Lisp, COBOL, APL, C; ...
 
Then think about Basic and Pascal, both popular languages, and more widely 
used than Lisp or APL.

For a long time after its introduction, Basic had poor text-string handling
and clumsy subroutines.  Some early implementations allowed strings, but
only allowed them to be used as indivisible pieces; there was no way to
concatenate them or pull out substrings.  Other implementations allowed
substrings, but used array notation for them, so that there was no way
to have an array of strings.  Even Dartmouth's Basic (as late as 1968)
allowed access to individual characters of a string only through a rather
contrived "change" command, which converted strings to numeric arrays.
And yet by 1968, Basic was already in widespread use.
 
What did Basic have that its cousin Fortran didn't?  I/O was simpler, since
format statements weren't needed.  Any arithmetic expression at all could
be used as a subscript.  And it was interactive.  (But IBM offered Quiktran,
an interactive implementation of Fortran, and that certainly never caught
on).

Similarly, ask yourself what Pascal had that Algol-W didn't.  A few more
data types, better declarations....

If you want your language to succeed, let it be innovative.  But don't
forget the importance of compiler that is cheap enough OR small enough
to run on many machines.
-- 
				Andy Behrens
				decvax!dartvax!andyb

preece@uicsl.UUCP (01/05/84)

#R:arizona:-678500:uicsl:6200004:000:625
uicsl!preece    Jan  4 14:28:00 1984

The 'change' command in Dartmouth Basic was really a very useful tool
(as I'm sure Andy remembers). It allowed the programmer to specify a
byte size in making the change, so that a variable number of
sub-components could be packed into a 36-bit word. It would have been
nice to have had more powerful string functions, though.

Basic also avoided the silly card format problems of FORTRAN, but I
think the principal reason it caught on was that it was very easy to
implement, allowing the early micro implementors to produce a useful
language that would run in a small, slow machine.

scott preece
ihnp4!uiucdcs!uicsl!preece