Slashdot Mirror
A Brief History of Programming Languages?
Aviancer asks: "French computer historian Éric Lévénez has compiled a family tree of programming languages that I found quite interesting. This prompted me to wonder if there was any controversy on the issue of language lineage and my searches found another page on the same topic. I thought I'd pull an 'ask the audience' to see if there were any corrections on either (both?) pages to be made." What other computing language origins are you aware of that may not be mentioned in either page?
Might have been updated lately, though. Always interesting, though. There's one for UNIX, too.
"These people look deep within my soul and assign me a number based on the order in which I joined" --Homer re:
here, maybe?
Better not tell IBM!
Neither diagram shows any, but I think it could be argued to exist--the keywords struct and union, long and short (note that the "at least 64-bit type" C9X mandates is called long long int, just as it would likely be called in Algol 68 for a target where int is 16 bits), the notion of coercion. (There may well be others I am overlooking.)
The Caml language (pronounce "Camel") is missing.
Caml is a programming language, easy to learn, easy to use, and yet amazingly powerful.
It is developed and distributed by INRIA (the main French research institute for computer science), since 1984. It is freely available for Unix, PC or Macintosh.
There exist two flavors of Caml: Caml Light and Objective Caml. Caml Light is merely a subset of Objective Caml, especially designed for teaching and learning the art of programming. In addition to the Caml Light's core language, Objective Caml features a powerful modules system, full support to object-oriented paradigm, and an optimizing compiler.
More information here.
Believe it. The only thing it influenced was the name.
I suspect that by "runtime typed" you mean dynamically typed (typing determined at runtime). A language can be both strongly typed *AND* dynamically typed. Their orthogonal.
;) ]
dynamically vs. static
strong vs. weak.
Perl is dynamic and weak
Lisp is dynamic and strong [or static and strong if you want
Python is a strongly typed language. It is in the class of strongly- and dynamically-typed languages. Read this article on Python's type system for a good overview and a little information on "type" terminology.
the growth in cynicism and rebellion has not been without cause
I've had the O'Reilly poster on my wall since they released it. So when I saw the graphic on this guy's site, with a January 16, 2005 copyright, and no reference of O'Reilly's poster, I thought it smelled fishy.
g _lang_pos ter.pdfh tml#02
Just take a look at the two images:
http://www.oreilly.com/news/graphics/pro
vs
http://www.levenez.com/lang/history.
and tell me you don't see the similarities.
Anyway, so I thought this guy ripped off O'Reilly's poster, but, as it turns out, if you look in the small print on O'Reilly's poster, you'll see that he was the legitimate creator of the image. I even realized that it's been updated a little bit since O'Reilly released it.
So, yeah, we've seen this story before, however, the link provided in the summary above is new and newsworthy, becuase it gives more links to learn about each individual and family of languages and updated the previous graph.
She loves me: 09F911029D74E35BD84156C5635688C0 She loves me not: 09F911029D74E35BD84156C5635688BF
Dynamic vs. static (or runtime vs. compiletime) and strong vs. weak. Dynamic/static typing is determined by when the type requirements are detected and enforced. C is statically typed - there's no runtime manipulation (or even concept of) types at all. C++ is mostly statically typed but has some runtime typing capabilities. Java is largely statically typed but also checks types at runtime. Python is entirely dynamically typed.
Strong vs. weak affects what kind of type operations are allowed. Typeless (or single-type) languages like TCL are the weakest type, because they allow any operation on any type. Perl has multiple types but does lots of implicit conversions, making it weakly typed. Python performs very few implicit conversions (mostly between different representations of float) and therefore is strongly typed. Pascal doesn't even allow type conversion between pointers or different sizes of arrays and is therefore *really* strongly typed.
There's also some other characteristics of typing, like whether it's class based (C++), does or does not allow user defined types, distinction between UDTs and primitive types, Objects vs primitives, duck typing, etc.
For those, like me, who have no idea what this guy is talking about, see this.
Fortran is always shown as having come from a vacuum, but surely it was inspired by the various "Autocode" languages, of which "Mercury Autocode" is the most famous. (Note: this was all before my time.)
:= ("x", 42);
Smalltalk is derived from Alan Kay's earlier language, Flex, which in turn stole heavily from Euler (Kay confirms this), which was the language Wirth designed before he did Pascal.
Euler was an early example of a dynamically typed, garbage collected language with an algol-like syntax. Now we have python, javascript, and so on.
Python is heavily based on ABC.
Euler must have been a primary influence on Setl, which in turn influenced other languages. Setl was a dynamically typed, garbage collected language with an algol-ish syntax, with arrays (called tuples) and sets as first class values. The List comprehensions of Haskell (and more recently Python) come from Setl. Setl is the first language I know to have the 'slice' notation for extracting subranges from a list:
list(i:j)
list(i:)
Although, i was 1 based, not 0 based, and j was a length, not an index. This slice notation was picked up by Icon, which changed j from a length to an index, and introduced negative indexes. From Icon, slice notation migrated into Python, presumably via ABC (I have no ABC documentation to check), where indexing changed from 1 based to 0 based.
The type names in C all seem to come from Algol 68. They couldn't have come from B or BCPL, which do not have types. Examples of C/Algol 68 type names include "int", "char", "long int" and "void", as well as "struct". This is C:
struct {char c; int x;} s = {'x', 42};
This is Algol 68:
struct (char c, int x) s
Algol 68 has a +:= operator, but I think that comes from C. This is speculation, based on the observation that C's += operator was originally spelled =+, then changed due to the ambiguity of parsing x=+y.
The second link shows Javascript decended from Java, which is surely wrong. Javascript was developed with no knowledge of Java. It was originally called LiveScript, then changed to Javascript for marketing reasons. I'm pretty sure that Javascript/Livescript got its object system from Self, the first prototype-based object oriented language. Self descends from Smalltalk.
I have written a truly remarkable program which this sig is too small to contain.
Pascal is dead. Object Pascal with various other extensions lives on. It's called Delphi.
What do schools use now as the teaching language? Surely not C. I have nothing against it but it isn't for beginners.
They use Java. Or maybe soon C#
That shouldn't really surprise you too much, considering Niklaus Wirth was the man behind Pascal, Modula, Modula-2, and Oberon.
Modula-3 exists between 1985 and 1990, 9th down.
|>>?
Plankalkül was developed in the first half of the 1940ies by Konrad Zuse.
Wikipedia has(as usual) for more information.
It's true on both time and causality.
Alan says so himself here
Read more of this story at Slashdot.Read more of this story at Slashdot.Read more of this story at Slashdot.
And then there's a whole different class of langauges: math packages that allow programming from within. Heck, minesweeper is even included in Matlab as an example. You an define classes, new data types, etc. I know that quite a bit can be done in Mathematica and Maple as well.
It'd be interesting to see where these fit in, since they have some elements of various languages. (e.g., in Matlab, indexing starts at 1, but much notation is C-like, and some other things are very Java-like.) -- Paul
OpenSource.MathCancer.org: open source comp bio
Because BASIC was originally intended to teach concepts that would later be used in FORTRAN programs.
Also, what about the lead-up to Visual Basic? More or less, after QuickBasic 4.5, we got PDS 7.1 (IIRC - Professional Development System - essentially QB4.5 with some DOS windowing enhancements and a slightly modified IDE), then came Visual Basic for DOS (still a lot of similarities to QB4.5 and PDS 7.1 - but with much greater control of windowing capabilities, and I think it allowed for easy mouse integration and event-driven code routines), then VB 1.0, I think (for Windows 3.1? Can't remember)...
QBASIC 1.1 was some weird thing they threw into DOS around version 5 or so, and kept in some form or another all the way through Windows 98 or so. It came out after VB for DOS - it may have even been released after VB3.0 (??) - strange release...
Reason is the Path to God - Anon
Shame you are AC. I hope you see this :
The Brandy Basic V Interpreter
What is it?
Brandy is an interpreter for BBC Basic (or Basic V as it is refered to here) that runs under a variety of operating systems. Basic V is the version of Basic supplied with desktop computers running RISC OS. These were originally made by Acorn Computers but are now designed and manufactured by companies such as RiscStation, MicroDigital and Castle Technology.
What does it run on?
The interpreter runs under RISC OS, NetBSD, OpenBSD, reeBSD, Linux, Mac OS X, Amiga OS, DOS using the DJGPP DOS extender and Windows as a console application. The program is written in ANSI C and comes in source form so it should not be difficult to compile it to run under other operating systems.
Brandy is distributed under version 2 of the GNU General Public License.
The current version of the program is 1.16 (January 2004).
There are places where the networks are not touching,and there are places where they are-Boeing's Lori Gunter
So, Perl is indeed strongly typed (for built-ins), and late-binding dynamically typed (for references and user-defined types).
Maybe if you changed it to under 30...
Common Lisp is strongly, dynamically typed. It has been for a long time. There are, of course, other language attributes than strength and time of datatyping, but those are what you're talking about.
Common Lisp is also object-oriented and beats every other language I know in that arena.
On top of that, with a good Lisp compiler (such as SBCL, CMUCL, or even GNU Clisp, just to name a few free compilers), it is as fast as any other language, even statically typed languages such as C; but particularly faster than other dynamically typed languages.
Currently still being developed and used globally, with at least 750,000 + users all around the world.
Currently offered by multiple vendors, runs on all Unix, Linux, M$ systems, except maybe on the 'big iron' IBM boxes. Current vendors with products that are supported are Thoroughbred, Basis, and Providex.
1. The PDF chart lists .Net as a separate item and links each of the supported MS languages to it. I think this is an accurate representation.
2. ASP = VB6. You could include ASP as an offshoot of Visual Basic if you like, but it has exactly the same snytax. The real changes came with VB.Net, which is included in both charts.
3. Dylan is included in the PDF chart as an offshoot of C++ and CLOS.
4. Nope, no Hypercard.
5. I suppose so. I don't really have any comment other than I'm not sure how legitimate sh is as a actual language.
6. Erlang is included in the PDF chart as an offshoot of Prolog and Common Lisp.
7. I don't see Cilk on either chart, which is funny since I'd actually heard of it before today. One could probably argue that it isn't different enough from standard C, but I think the implications of parallelism are probably enough to merit its own place on the chart.
8. Mercury is included in the PDF chart as an offshoot of Haskell, SML 90, and CLOS.
9. Funny, but you almost could do that... Is there any library or language that hasn't been grafted onto Perl at this point?
According to wikipedia, the "commercial variant" of Flow-Matic started in 1955. http://en.wikipedia.org/wiki/FLOW-MATIC Wikipedia lists FORTRAN as being developed in 1954-1957. However, the forbears of Flow-Matic definitely preceed FORTRAN, as you'll see below:
B-0 was the original name of Flow-Matic. More interesting perhaps is that both owe influence from A-0, a language developed for the Univac I, and the first language to have a compiler. (Flow-Matic was also developed for the Univac I.) For that reason alone, the tree should probably include it. (Perhaps even as the "root" of the modern languages.) One could argue that the inclusion of Flow-Matic on the chart encompasses A-0, although I would argue that A-0 should probably simply replace B-0 on the chart, since Flow-Matic and B-0 are one and the same.
http://en.wikipedia.org/wiki/A-0
// harborpirate
// Slashbots off the starboard bow!
Alan Kay also credits influence of LISP in the essay, as shown in the Levenez chart
It's a take off of the Nicene Creed, not the Apostle's Creed. This Creed was written at the Council of Nicea in A.D. 325, in an attempt to settle some theological disputes of early Christianity. It was later revised at the Council of Constantinople in A.D. 381.
Since the Roman Catholic, Eastern Orthodox, Presbyterian, and most other Protestant churches affirm this creed, its says pretty accurately the basic stuff that most Christians believe in. And speaking of most Christians, the use of the word catholic in the Creed means "universal," not "run from Rome by a frail man wearing a silly hat."
HyperTalk had about a kajillion users. It certainly deserves a place in this geneology. I'm not sure exactly where to put it, but it's certainly related to Smalltalk as a close cousin if not a descendant. For completeness, AppleScript should be listed as a descendant of HyperTalk.
I don't know why the PDF lists C++ as an ancestor of Dylan. I was somewhat involved in the development of Dylan, and Scheme, CLOS and Smalltalk were the main parents.
Squeak is the current leader of the Smalltalk bloodline. www.squeak.org
I believe that APL, DIBOL {an old DEC COBOL wannabe} language} and DBL a derivative of DIBOL are also missing. I seem to remember others circa the Xerox Sigma 9 are mising from the lists. I believe there were a variety of old DEC & Xerox etc. languages that need could be added.
I could not find any reference in either list to Xerox PARC's Mesa, which is often credited as one of Wirth's inspirations for Modula-2.
In the interview Daddy, Are we There Yet Alan Kay mentions that he read a paper on Simula in 1966. As he says in the interview much is lost to the programming community because we don't have a good sense of history.
re: the first one http://www.levenez.com/lang/history.html it is BASIC, not Basic. Also, there was MS-BASIC, GW-BASIC, BASICA, Apple BASIC, MS QBASIC, MS QuickBasic, QuickBasic Extended/PDS. Also, they list JScript, and not VBScript; PHP and not ASP. Also, this one is missing Rexx. http://people.mandrakesoft.com/~prigaux/language-s tudy/diagram.pdf seems to have some data that is off to the right of the page, including what appears to say "PostScript".
Video Production Support
The INTERCAL tree looks something like this...
INTERCAL (1972) --> C-INTERCAL (1990) --> THREADED INTERCAL
INTERCAL also has had some influence on other languages, such as unlambda,
so an argument could be made for including it in the chart. (Mind you, I
would not want to have to defend such an argument against all possible
rational counterarguments.)
Cut that out, or I will ship you to Norilsk in a box.
The term *used* to cover languages where variables have types that can be (and conventionally are) checked at compile time.
However, since the term had strong connotations, advocates of languages where values have types that can be (and conventionally are) checked at run time, started claiming that their languages are also strongly type cjecked.
As a result, the term is today meaningless. What I use instead is talking about static typechecking (type errors detected by the programmer at compile time) and dynamic typecheckig (type errors detected by the user at run time).
Python rely on dynamic typechecking.
You should try to find an archive containing old Byte Magazines. When Smalltalk-82 came out, they devoted a whole magazine to it and the Xerox Alto.
In the magazine you will find that the people based Smalltalk indeed on the work done for Simula, also for the first version of Smalltalk (Smalltalk-76, I think).
Well the strong/weak typing issue is pretty old fashioned.
... /* OK */ /* Compiler trusts you but shouldn't */
/* compiler trusts you */
Strong and weak typing is not about doing implicit conersions. It's about trusting what the programmer is doing.
K&R C was weakly typed (I'm reaching back decades here so cut me some slack). This was especially fun with pointers which were pretty much all just addresses to memory that usually were implemented as ints.
E.g.
int incrAt (int *x) {
return ((*x)+1);
}
int i = 1;
float f = 3.14;
i = incrAt(&i);
i = incrAt(&f);
ANSI C is more strogly typed:
i = incrAt(&f); / *compiler complains */
But, it is still happy to trust you if you insist:
i = incrAt((int *) &f);
Strong typing doesn't have anything to do with implicit conversions, in my opinion. Consider the following expression:
2 * 3.5
What every sensible language does is this (in prefix notation):
floatMult(intToFloat(2),3.5)
as opposed to:
intMult(2,2.5)
or
floatMult(2,3.5)
which would give the wrong answers. The situation is not different for complex types like objects where there are well defined operations and type promotion schemes.
What strong typing vs. weak typing is, or was about in any case, was safety vs. the amount of work the compiler or runtime system had to do.
These days with powerful systems and overcomplex problems, safety is paramount.
With respect to static and dynamic, they mean exactly as you say.
Post may contain irony: discontinue use if experiencing mood swings, nausea or elevated blood pressure.
That's a better idea. Putting "BrainFuck" on your resume will doubtless highly speed up its evaluation by most potential employers.
//Information does not want to be free; it wants to breed.
I'll bite on this troll because it plays on so many misconceptions.
[Lisp] has never produced anything of use (actually maybe, but I'm keen to hear of some *large* *all-lisp* program that does something truly useful
How about an entire operating system? Or have you never heard of Lisp Machines? A full-blown editor, or have you never heard of Emacs? How about a state-of-the-art compiler with incremental compilation, on-demand linking, better-than-human-hands optimization, or have you never heard of Common Lisp?
[L]isp is the *worst* language to start out with. For exactly the reason you point out. utterly horrible syntax. And that's all you worry about as a beginner learning lisp.
Have you spent time teaching programming courses? I have. Have you studied the pedagogy of programming? I have. When you teach programming based on C, and similar syntax-laden languages, you spend 1/2 to 2/3 of the course detailing syntax. When you teach Lisp or its derivatives, you spend one week on syntax, and the rest of the term on concepts. Why? Because the syntax of Lisp is incredibly simple and this frees the course to concentrate on more important issues in programming.
((((((((((neq lisp simple))))))))))))))
oh crap! to many close paransss...
You probably never used an editor that had proper indenting and parenthesis matching. In Emacs (and related editors like Epsilon, Jove, microemacs, mg, etc.) you never wonder how many parentheses you need because it's obvious. Parentheses are not a burden.
Put my fist through my alarm clock with its ding-dong death inside my ear. - The Blackjacks.