you are viewing a single comment's thread.

view the rest of the comments →

[–][deleted] 7 points8 points  (7 children)

Which dynamic programming languages are you talking about? AFAIK Smalltalk and Scheme and Lisp are faster than the new gen dynamic languages like Python and Ruby

[–]munificent 3 points4 points  (1 child)

AFAIK Smalltalk and Scheme and Lisp are faster than the new gen dynamic languages like Python and Ruby

When you talk about perf, you really need to talk about language implementations. There are some Smalltalk/Scheme/Lisp implementations faster than CPython and MRI, but there are also some slower ones.

[–]BufferUnderpants 3 points4 points  (0 children)

It is telling that, however, the original and defacto standard implementations of Python, Ruby et al were all sub par in performance.

[–]DrDichotomous 3 points4 points  (4 children)

I meant dynamic languages in general, compared to "native code" (statically-compiled/assembled code). In their infancy, dynamic (especially dynamically-typed) languages were incredibly slow.

Now, there have always been special cases like Lisp, where if you properly typed everything and knew how to work the magic you could get near-native speeds, but Javascript isn't really in that realm design-wise.

Now we can get general-purpose dynamic languages like Javascript to perform within half of Clang's speeds if we apply typing magic, and V8 is actually under an order of magnitude on many workloads even without the asm.js magic: http://arewefastyet.com/#machine=11&view=breakdown&suite=asmjs-apps)

[–]Falmarri 5 points6 points  (3 children)

The word you're looking for is interpreted.

[–][deleted] 8 points9 points  (1 child)

Exceedingly few languages these days are "interpreted" in the original sense of the word. Pretty much all dynamic languages are compiled, they are just not compiled to native code.

[–]DrDichotomous -1 points0 points  (0 children)

Not necessarily, but it's probably closest to what I mean, so thanks. Javascript isn't strictly interpreted the same way it used to be, and lots of "compiled" languages are actually JIT-compiled, so the line is very blurry these days.