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?

Comments

This has been around forever

[MattGWU]

Might have been updated lately, though. Always interesting, though. There's one for UNIX, too.

looks familiar

[ambrosine10]

here, maybe?

Python *is* strongly typed

[Rob Riggs]

The parent did not deserve to be modded up as "informative". An accurate title for the post would be "Python is not statically typed."

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.

Original and Updated

[douthat]

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.

Just take a look at the two images:
http://www.oreilly.com/news/graphics/prog _lang_pos ter.pdf
vs
http://www.levenez.com/lang/history.h tml#02

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.

Re:Python's not strongly typed

[arkanes]

There are 2 axis of typing. Note that they are scales, not boolean attributes

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.

Karma Whoring!

[wiggles]

For those, like me, who have no idea what this guy is talking about, see this.

Some corrections and additions

[dmoen]

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

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 := ("x", 42);

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.

Simula and Smalltalk

[tpv]

Which is true if you look at time, but probably not if you look at causality. It's very likely the people who invented SmallTalk didn't even know about Simula, or realized that it was "object-oriented".

It's true on both time and causality.
Alan says so himself here