As Languages Evolve...

naph writes "It seems that as programming languages have developed there has been a steady increase in the level of abstraction they use. Early languages were all very low-level, but successive generations have become higher and higher. Is this trend going to continue, or do you think we've reached a kind of happy medium between power and abstraction? Would developers prefer higher level languages, or is the direct control of things good? I was just wondering what other developers out there thought of this."

Comments

Understand the Economics of it

[Phouk]

"Higher abstraction" for a programming language means it's farther away from the requirements and constraints of the cpu, and closer to the problem domain.

cpu ------> abstraction ------> problem

As a result, the more abstract language is often less efficient for the computer to execute, but allows the programmer to describe the problem to the computer faster. That is, it makes him more productive, in the sense of...

productivity = features developed / times spent

Now,

• the amount of functionality expected of a program keeps rising and rising,
  
• the cost of spending additional cpu cycles on more abstraction keeps going down and down,
  
• programmer time stays at (very roughly) the same price.
  

As a result, the "sweet spot" in the tradeoff between programmer time and cpu cycles now is with more abstract languages than it was 10 years ago.
This is also why in the past the abstraction level of "mainstream" languages has steadily increased (machine language -> assembler -> macro assembler -> COBOL/FORTRAN -> modular/structured languages -> object-oriented languages).

This is also why I firmly believe the abstraction level will keep going up, through stuff like:

• stronger influence of functional abstractions on mainstream languages (e.g. having closures and higher-order functions)
  
• support for "stronger" abstractions through features such as design by contract, aspect-oriented programming, generics etc.
  

I also expect more new languages to have dynamic instead of static typing, which is also a way to attain higher programmer productivity (especially for refactoring) at the cost of compiler/runtime efficiency.

One more note: Before you argue against higher abstraction, please check if your line of reasoning could have been used as an argument for assembler and against higher-level languages. If so, maybe something is wrong with it...