The JIT developed for SELF is the genesis of Hotspot.
JRuby guys have a quite good implementation making use of Graal, and Ruby is not less magical than Python.
In the end it boils down to how much the community prefers to keep on using C, or improve PyPy.
EDIT: Fixed auto-correction induced typo.
In the case of python it's clear that the heavy reliance on c extensions is a blessing and a curse: it's kept python relevant in communities like science even though it isn't very fast. However one of the lessons of Graal seems to be that such extensions can seriously prohibit improving performance, since they are opaque to JITs.
There's a few talks by Chris Seaton (e.g. https://www.youtube.com/watch?v=YLtjkP9bD_U) on the topic.
I'm not particularly convinced that Julia's object model leads to inefficient memory access either.
> each variable can have one and only one (possibly abstract) type
This is generally untrue except for a rarely used feature allowing declaration of local variables with a certain type (assignment to such variables automatically converts to the declared type). Is this documented incorrectly somewhere?
Julia's object model allows a spectrum of array types. At one end, `Vector{Any}` is a Python-like array, and at the other, `Vector{Float64}` is a C-like (or NumPy-like) array with a concrete element type. If the element type is abstract but more constrained than `Any` then you get something in between these extremes. This includes array types like `Vector{Union{Float64,Void}}` and `Vector{Real}`, both of which have abstract element types smaller than `Any`. The former can still store values inline like C arrays, thanks to recent work on efficient representation of unions small values. The latter needs Python-like vector-of-pointers representation because the set of kinds of values it can hold is unbounded since you can add new subtypes of `Real` at any time.
No, I just got myself massively confused at how code_warntype works. Please just disregard everything I said in the above comment.