elif: sh, python
elseif: PHP, Modula-2, Dylan, Eiffel, Oz, Matlab, Julia
elsif: Perl, Ruby, Ada, Modula-3, Tcl,
The documentation for the graph module (data structure, not charting) suggests that Julia is not a toy language at all. The interface was inspired by the Boost Graph Library! http://julialang.org/Graphs.jl/interface.html
So far I have been using C++ for high-performance, time-critical code and Coffeescript for quick prototyping or for code where performance isn't a bottleneck (out of all the languages I know, I never got around to learning Python for some reason...).
Programming languages are a little bit of a hobby of mine, so I've messed around in Haskell, Lisp, and Clojure. I really like the design of Clojure, particularly all of the concurrency features, but I don't think it has the speed or the libraries for scientific work.
Julia is the first "scientific" language I've seen that actually seems well-designed instead of ad-hoc (i.e., someone with graduate work in CS was actually involved in its creation). The fact that the authors know what a legit type system is already becomes an upgrade to anything Fortran or C++ could offer. I never thought the OO paradigm (subtype polymorphism) in Java or C++ worked well at all for scientific work. Maybe some people found it useful, but I always thought it was forced.
Aspects of Julia I really like:
* Libraries - The ones that are in Julia so far are fast (and use well-known numerical libraries like FFTW and BLAS) and easy to use. They're geared toward scientific work, so this is perfect for my research.
* Syntax - I like the brevity. I don't necessarily like that blocks must be terminated with "end" but that's just a personal thing.
* Speed - Wow. I'm still amazed this is as fast as it is since it feels so much like an interpreted language. All that work with the LLVM is paying off. I almost wonder if in the long run this could be faster than C since you can provide information about the program to itself while its running for on-the-fly optimizations.
* Homoiconicity - I can't say that I've actually had a legit use for this yet, but I'm glad that it's there for some reason. I wouldn't say the language is 100% homoiconic (to the extent of Lisp), but it's pretty close.
My main concerns with Julia at the moment are:
* Will it continue development? I'd hate to write a whole suite of software in a new language that no one else will use because the language goes obsolete.
* What's with this weird confusion with tuples and arrays? It seems like there's some situations where these things have overlapping purposes.
* Documentation can be slightly confusing. Sometimes it's hard to tell exactly what a function does or what its arguments are supposed to be (without going into the REPL and using "methods"). Example function calls would go a very long way toward helping here.
My sense is that this is a labor of love as well as necessity, and the folks behind Julia are in it for the long-haul. This is also not their first rodeo: several core folks were involved with StarP from Interactive Super Computing.
The highly-active community is probably (at very least) 60-strong and growing quickly (based on 10+ core commits, or active package contributions). Many more people who have made contributions or pinged the list keep coming back intermittently, and I think it is safe to assume that semi-active/patiently-awaiting-something users number in the low hundreds (based on thousands of downloads).
What's with this weird confusion with tuples and arrays? It seems like there's some situations where these things have overlapping purposes.
Tuples have been sort of ugly stepchildren, but there is a pending pull request to be merged after 0.2 release which will give tuples a massive upgrade (performance boosts and use as SIMD vectors, among other things).
I'm a little concerned because it seems to be doing a fully optimizing recompile on every invocation.
With regard to Pandas, there is a very nice and rapidly-maturing data frames package: https://github.com/JuliaStats/DataFrames.jl