Reply to Message

Well, let's take a look:

CobraA1 1st Jun 2009

Well, let's take a look at what happened:

-We started with ASM. Fast language on systems that these days would be considered painfully slow. But, it's a 1:1 matching with machine code. And it's as fast as you can get.

-We started adding more instructions. CISC was victorious. Hello increased compiler complexity. Hello increased complexity of generated code in higher level languages.

-We moved to compiled languages. A lot easier to read, but at a price: One instruction in a compiled language doesn't match one instruction on a compiler. Complexity is often hidden under single statements.

-We started using OOP and recursion. Both are fantastic ways to make a little bit of high level code become a pure mess in machine code.

-We added interpreted languages to the mix. Now it takes many lines of code to do what used to take one line of code. JIT made it a bit better, but it's still nowhere near as efficient as a fully optimized compile, and the JIT adds to the memory requirements.

-We started adding functional languages and other paradigms to the mix. More ways to add overhead with incredible ease.

-Now we're combining several languages in one system: HTML, CSS, JavaScript, etc. Now we have not one but several interpreters competing for memory and CPU.

-And oh, yeah, we decided to jump onto what has become the world's largest network. Hello online crime, and hello a lot of extra code needed to secure everything.

-We write a lot of stuff in XML now. Goodbye efficient, fast file formats and protocols, hello extra space and power needed for a parser.

JavaScript? It's a super high level language that can manipulate other languages. It's so far from how the machine works that it's incredible that it works at all.

You want to reverse the trend? Really?

The trend is, quite frankly, because we decided that we preferred high level languages and protocols over low level languages. As simple as that.

The problem isn't really that we haven't been trying to be fast. The problem is, quite simply put, a tradeoff between high level languages and low level languages. We've decided to abstract everything away.

. . . and the price for abstraction is performance. You can't reverse the trend unless you stop abstracting everything away so much.