Yes [1]. Invokedynamic (JSR-262). Quote from an older article [2]:

"... enable[s] implementers of compilers for dynamically typed languages, that is, the people who develop compilers for languages such as JRuby and Jython, to generate bytecode that runs extremely fast in the JVM."

[1] http://blogs.oracle.com/jrose/entry/jsr_292_launched_in_java

[2] http://java.sun.com/developer/technicalArticles/DynTypeLang/...

Indeed, As Charles Nutter (JRuby) wrote:

"There’s a very real chance that invokedynamic could improve JRuby performance many times, putting us on par with our statically-typed brothers like Java and Scala. And that means you can write Ruby code without fear. Awesome."

http://www.engineyard.com/blog/2011/jruby-1-6-released-now-w...

So invokedynamic is already wired into JRuby? I can just install the Java 7 runtime and see significant performance improvements?

JRuby 1.7 has the major Invokedynamic changes. You can play with trunk for now.

Whoo-hoo! Time for the Perl port.

Good luck with that wish.

I would have to lookup the serious academic paper that says peel is technically unparsable in the same ways as PL/1. I think to date there have been two aborted perk on java efforts

Not sure if perl6 has the same properties mind.

I think perl6 is meant to have mutiple implementations.

I wish I had checked that over I just saw that my phone mangled perl twice

Yes, Clojure will profit from Fork/Join: http://download.oracle.com/javase/tutorial/essential/concurr...

For example see here, pvec: http://clojure.org/other_libraries

Of course, improvements like the GC1, improvements in HotSpot etc, they all will make Clojure apps run even faster.

Oh nice, I thought F/J got pushed into 8. Glad to see I was wrong.

For dynamic JVM languages, the new invokedynamic bytecode is a huge performance boost.

Probably not. See what Rich Hickey said about this: http://clojure-log.n01se.net/date/2008-09-03.html#09:13a

For clojure no, but jRuby and several similar languages are getting a huge boost.

Have you seen any actual numbers on this? I've googled around a bit and can't seem to find any.

JRuby developer Charles Nutter claims that Java JDK7 gives a performance boost to JRuby, saying "On bench_threaded_reverse, Java 7 is 20% faster than Java 6, and JRuby plus invokedynamic is 20% faster than that".[1]

From http://en.wikipedia.org/wiki/JRuby with the [1] being

https://twitter.com/#!/headius/status/78282122997149696

I'm a little disappointed that people are still talking about tagged ints. There are so many better ways to avoid the overheap of integers being a refrence type (namely type specializing everything under the sun, particularly your JIT'd code and data structures).

Could you please tell me something more about it? Tagged unboxed data seems to be a nice solution for me.

Well, the problem with it is it has a negative performance impact on everything else in your codebase, the first time you see any pointer you need to check if it's tagged or not. The advantages are clear: you don't need to allocate anything on the heap for integers. Which means you're sacrificing performance on everything else, for integers. Solutions such as automatic type-specializing containers don't carry this downside, and carry the same upside. For example at the moment PyPy type-specializes dictionaries. Python has a single `dict` type, which can store anything, but we type specialize and fallback if we get it wrong. Similarly, we're working on type-specializng lists, tuples, and user objects. If there's anything more I can answer let me know.

Yes, invokedynamic[1]

1. http://blog.headius.com/2008/09/first-taste-of-invokedynamic...