Just rephrasing what others have said in this paragraph. Each language has it's advantages and pitfalls, and DSLs can often be better than a generic language for a given task. When mixing tons of languages together, it's difficult to have an intuitive syntax.
That being said, I still think it's possible to have an "ultimate" programming language. But really, it'd just be an interface for using multiple languages side-by-side.
Perhaps it could look something like this (The memory-specific routines are implemented in C, most other code in Python):
<language lang="C">
#include <textgraphics.h>
unsigned short* screen = (unsigned short*)(0x06000000);
int* keys = (int*)(0x04000132)
const int key_left = 1 << 5;
const int key_right = 1 << 4;
int keyIsDown(int keyCode) {
return !(keys & keyCode);
}
void plotPixel(int x, int y, unsigned short color) {
screen[y*240+x] = color;
}
unsigned short RGB16(int r, int g, int b) {
return (r<<10) + (g<<5) + b;
}
</language>
<language lang="Python">
while True:
x = 120
y = 80
color = RGB15(16, 12, 24)
draw_text(0, 96, color, "Hello World!\n"*8)
if keyIsDown(key_left):
x = max(0, x-1)
plotPixel(x, y, color)
if keyIsDown(key_right):
x = min(239, x+1)
plotPixel(x, y, color)
</language>
To those of you who are curious, this is meant to be run on a GameBoy Advance =D (textgraphics.h doesn't exist, and most of the code was written from memory)
In that example, the benefits of Python weren't fully shown. But it's CW, so please do edit if you have a better example.
Some of you might think this seems a little far fetched. But consider Python with Cython. HTML with the script tag. In a way, we're already starting to move towards this kind of interface.
However, making a compiler for something like this would be difficult. Compilers for each language would have to be designed to interact with the master compiler so that variables could be accessed across different languages. On top of that, the number of times a variable is cast from IE: Python's int to C's int would be extremely high. And mixing interpreted languages with static ones could cause problems. Consider:
<language lang="C">
int functionA(int);
int functionA(float);
</language>
<language lang="Python">
functionA(someVariableWhoseTypeIsNotKnownAtCompileTime)
</language>
So in the end, mixing languages might not be suited well for those who really need the (execution)speed. But in cases where you truly do need raw speed, I'd be inclined to use a low-level language like C, and only stick with the simplest code, which this setup allows.
