A lot of programming language debates can be summed up in one big meta-debate that’s been going on since the 1950s: Lisp or machine language? That is, should programming languages move towards high-level abstraction and rely on smart compilers to keep things efficient (the Lisp side), or should they remain fairly close to the hardware and rely on humans to keep things correct and readable (the machine language side)?
(To be fair, there are a lot of debates that don’t boil down to this (the indentation fight is one of them) and there are a lot of languages that aren’t fought over in these terms, either. Those languages are domain-specific languages, used by people in one specific problem domain to solve problems in that domain. Cobol is the most-used domain-specific language, solving problems non-technical businesses have with payroll and other accounting chores.)
Over the past half century, programming languages have been increasingly moving towards the Lisp side of things, but there have been some notable reversals. For example, Algol and later C displaced Fortran and assembly language as general-purpose application-building languages, but C has resisted efforts from both C++ and Java to displace it totally. (They have in some places, but not everywhere.) Even now, with increasingly parallel computers being built (something C has a hard time handling), C isn’t going anywhere for the time being. In fact, very high-level language such as Haskell would probably be better for writing parallel code than most humans writing machine code would be*, but it seems the odds of a Haskell-like language taking over are slim.
*(Why would Haskell be better? Because it can enforce a very comprehensive set of constraints on how data is passed around – something called ‘referential transparency’, for one – that allow the compiler to generate extremely good code that would break most people’s brains if they had to write it by hand.)
However, parallel computers might finally force even the most backwards application-building companies to move towards more Lisp- and Haskell-like languages, because writing software that has to be split across 128 or 1024 different processors at once is hard. You have to think about what gets done by who to what when, and how that new information gets told to everyone else without causing a total meltdown. If you want to strike the Fear of Finagle into the heart of a poor C++ programmer, sneak up behind him and chant “Spinlock, deadlock, livelock, mutex!”
Simply put, it’s a lot easier to have smart people write the compilers and, effectively, only think about the hard stuff once, come up with the right answers, and encode them into the compilers the rest of us use.
Finally, something that is NOT a debate in my field of geekery: Anyone who thinks all programming languages are equally powerful rewrites Quake, Hexen, and Doom 3 in RPG for the AS/400. (If you don’t know what an overpriced washing machine would be doing with a rocket-propelled grenade, don’t ask what RPG really stands for.)