Slashdot Mirror
The History of Programming Languages
Dozix007 writes "For 50 years, computer programmers have been writing code. New
technologies continue to emerge, develop, and mature at a rapid pace.
Now there are more than 2,500
documented programming languages and O'Reilly
has produced
a poster called History
of Programming Languages, which plots over 50 programming languages
on a multi-layered, color-coded timeline."
The same program, written in 621 of the 2,500+ is here.
You can find this meta-language you speak of, if you read Godel, Escher, Bach By Douglass Hofstadter. It's called 'GLOOP'.
My blog
He was referring to Assembler.
===== Murphy's Law is recursive. =====
That being said, the lighter connecting arrows between languages (Lisp to Logo, Algol to almost everything else) makes the chart easy to follow and interesting to look at.
...and you run and you run and you can't stop what's been done...
One thing that has always bothered me is the lack of standards for basic syntax. Why not just have a standard for basic operators? For example does anyone really lose flexibility if we say statements are delimited by ';'? Or a standard syntax for if-then-else? e.g. perl's syntax is a pointless departure that adds no value.
Whoa.
It seems that Lisp holds the record for
"Longest Lived Language That Is Still Relevant Yet Underappreciated"
It just amazes me that something concieved that long ago is still going strong. I guess it makes sense, as it was concieved initially as a language for describing algorithms, then later implemented. With abstraction on the rise as it seems to be, this quality of being much closer to theory than practice is quite a useful one.
Its called machine code. Anything else is an abstraction (for that architecture--due to different architectures there can never be a true abstraction unless you take it all the way down to the and-or-nor-nand-xor-etc circuitry).
Its interesting to note that most people don't see history repeating itself with Java and C# (the fourth level of abstraction). The story goes as follows: in the late 60s, almost all systems programming was done in assembler(1st level), just for speed. In fact, no operating system was ever written in anything else than assembler, so there was no portable OS. People scoffed when UNIX was implemented in C (second or third level depending upon who you ask) in the mid 70s because it would be too slow. Of course computers get faster and a portable easy to edit OS took off.
Its really funny to hear people give the same arguments against Java and C# that are word-for-word the same as what was said about C.
Aaah, the nostalgia!
Anyway, I didn't see any programming language versions for functional languages (the ones I recognize are Haskell, ML and Miranda) after some time in -99.
Does that mean that they are dying out?
I've heard rumors of F# from Microsoft but I don't know if that is true.
It would be a pity if functional languages would die at this point in time since proponents of functional languages always used the argument that "they may be slow now but they scale really well on massively parallell computer systems" (because of no side effects) and we are at the brink of seeing multi-processor systems starting to go mainstream.
On a separate note, XSLT, which isn't a programming language in the traditional sense, is functional in its design. I think the designers of XSLT really put some thought into it. In any event, XSLT doesn't have any side effects, making it a functional language in a sense, and this means that it also should scale really well on massively parallell systems.
So, I guess the theory behind functional languages live on in one of the hottest technologies around today.
Also, the last version of Prolog was in -97. Pity, you can really do some magic in that language.
The Internet is full. Go Away!!!
Coincidentally, the guy who (for the most part) made Delphi actually left Borland and went to Microsoft, and he's now the lead architect of... C#. :o
I was disappointed to see Lisp not get much cred on that chart. First language with dynamic typing is worth noting. I've been reading up on Lisp (not coded a line yet) and have suddenly become disappointed in the entire programming world - right here there's a language with a featureset that it has taken other languages decades to catch up to.
Where is a language with the power of Lisp and the ease of Python? Python has some wonderful features in terms of speed and readability, but it is too tied to its primitives. After reading on Lisp, then going back to coding Python, I was really frustrated that the language wasn't better generalized - that all statements (if, import, etc) are hard coded - what if I want to make a custom block statement (like if or while) or something similar? Can't do that in Python, because you don't really have access to parsed code objects the way you do in Lisp.
I've looked at the modern Lisp languages (Common Lisp and Scheme) and I can't figure out which ones are worthy of my attention. Scheme seems like it has lost the intelligent simplicity of Python in favour of clumsy "special character" based syntax, while Common Lisp has many detractors that don't complain much of details. Is your complaint about Common Lisp based on all Lisp variants? Or is CL especially bad?
I know Lisp is not the ideal language - its ugly, illegible, and slower than compiled languages - but the fact is it existed at a time so far before many languages that pathetically failed to implement its features, so I'm a little confused at the way the computing world has ignored it, instead of trying to work its principles into modern languages (Python does a little, but ends up feeling cobbled together and inconsistent).
Is your complaint about Common Lisp based on all Lisp variants? Or is CL especially bad?
No, I just don't think that a proper Lisp has been implemented yet - I'm thinking of a language with all of the semantics of Lisp *plus* easily readable syntactic sugar. I'd like to see a standardized lisp that I can write and read as quickly and Python.
In Python we have a very succesful programming model, in Lisp we have potential for every conceivable programming model. Specializing the Lisp a little bit to optimize for pythonic programming would do a world of good.
I want do do
o = SomeClass()
instead of
(setq o (make-instance SomeClass) )
The latter might be semantically more elegant, but boy, it doesn't flow like the python variant.
As far as non-language-feature issue goes, Lisp does need a better (quantitavely and qualitatively - no "Functional Programming" people but people who can recognize the realities of programming today) community and one standard open source implementation. Availability of commercial implementations just doesn't cut it. And the one open source implementation should run on Windows too (no, Debian doesn't cut it).
Save your wrists today - switch to Dvorak
Well, that's what the scrolling text reads. The little blurb next to the picture and "1975" reads:
"...develop a BASIC computer language for the Altair 8800."
So at least in one place they were a little more humble....
>Its really funny to hear people give the same
>arguments against Java and C# that are
>word-for-word the same as what was said about C.
Not really: if java is going to replace c/c++ the way c/c++ replaced assembly for systems programming, then everyone would already be using lisp.
If java and the like are going to replace anything, its going to be vb/pascal and friends.
They didn't define what they consider a programming language (Turing complete? General purpose?). Powerbuilder and m4 are general purpose languages but I didn't see them on the diagram.
If domain-specific languages are allowed, I think these were overlooked:
BTW, you can download a more printer-friendly version here: Eric Levenez's Computer Languages History
Also, a German version is available here: German PDF
Okay, good to see someone has come to the same conclusions I have. Python is a wonderful language, but the problem is that it has grown osmotically - the language itself is good (not great, but good), but the real popularity of it comes from its incredible amount of "batteries included".
IMHO, a real, true, ultimate pure _language_ (not standard library) needs to be polished up for an opensource successor. Something with the power of Lisp and the legibility of Python. I'm thinking of something very similar to python except that code-based blocks should be handled as custom objects like everything else in Python.
In Python, the statement
class foo(bar):
def __init__(self):
self.baz = "foo bar baz"
is using the interpreter to auto-insance a bunch of standard Python objects (a class and a method, which is than in turn wrapped with an instancemethod) based around code objects. I can subclass the interpreter "method" object or create new substitute ones in its place, but if I want to use them in the interpreter, then I have to instance them the normal way, using
mycustommethodinstance = mycustommethodclass(constructorarguments)
whereas the main method object gets the nice
def funcname(args):
statement. This is the biggest failure of Pythons generalism - its inorexicably tied to its core objects, so that if you are using it like Lisp as a fully custom-made lexicon, you still have to either a) tear the contents out of the engine objects and relocate them into your own objects or b) use stupid constructors like
myfunc = myfuncclass("myname", "my massivestring of text that is actually the whole code block that this contructor will compile into code but I have to enter it as a string like this its kinda stupid eh?")
Not very nice. I want to make custom if and class statements, replace the implicit behaviour that typing i=1 creates an int object instead of some other custom object I want it to make. Likewise, I want to use other datatypes otehr than a true python Dictionary object as the local namespace or the global namespace (well, the globals can be any kind of mapping, actually).
A generalized Python would be my dream language - Python, but where all the core objects and statements (like "if" or "class") were part of the standard library.