Question

Is it possible to design something like Ruby or Clojure without the significant performance loss in many situations compared with C/Java? Does hardware design play a role?

Edit: With significant I mean in an order of magnitudes, not just ten procent

Edit: I suspect that delnan is correct with me meaning dynamic languages so I changed the title

Answer 1

Performance depends on many things. Of course the semantics of the language have to be preserved even if we are compiling it – you can’t remove dynamic dispatch from Ruby, it would speed things up drmatically but it would totally break 95% of the all Ruby code in the world. But still, much of the performance depends on how smart the implementation is.

I assume, by “high-level”, you mean “dynamic”? Haskell and OCaml are extremely high-level, yet are is compiled natively and can outperform C# or Java, even C and C++ in some corner cases – especially if parallelism comes into play. And they certainly weren’t designed with performance as #1 goal. But compiler writers, especially those focused onfunctional languages, are a very clever folk. If you or I started a high-level language, even if we used e.g. LLVM as backend for native compilation, we wouldn’t get anywhere near this performance.

Making dynamic languages run fast is harder – they delay many decisions (types, members of a class/an object, …) to runtime instead of compiletime, and while static code analysis can sometimes prove it’s not possible in lines n and m, you still have to carry an advanced runtime around and do quite a few things a static language’s compiler can do at compiletime. Even dynamic dispatch can be optimized with a smarter VM (Inline Cache anyone?), but it’s a lot of work. More than a small new-fangeled language could do, that is.

Also see Steve Yegge’s Dynamic Languages Strike Back.

And of course, what is a significant peformance loss? 100 times slower than C reads like a lot, but as we all know, 80% of execution time is spent in 20% of the code = 80% of the code won’t have notable impact on the percieved performance of the whole program. For the remaining 20%, you can always rewrite it in C or C++ and call it from the dynamic language. For many applications, this suffices (for some, you don’t even need to optimize). For the rest… well, if performance is that critical, you should propably write it in a language designed for performance.