I was curious about the elseif complaint so I looked into how different languages do it. This is nowhere near a comprehensive list but elif seems to be the least popular.
It's surprising it's less popular than elsif. I'd think you'd either go full on with shortening it (kind of surprised there's no "ef" now that I think about it), or just spell it right.
I have been using Julia extensively for about a year as a data analysis tool / R and Matlab replacement. I can say it is very good, especially well suited for exploring and processing large amounts of data. Often when you're trying to understand a set of data, you don't know what kinds of filters and transformations you're going to want to try. If those transformations end up not being easily vectorizable, then they will be dog slow to run in R or Matlab, and probably inconvenient and more difficult to create in C. For these situations, Julia is perfect.
Wow, I may have to try this Julia thing out. For some reason I had associated it with Lisp or the JVM.
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
I have just started learning Julia this past week. I do scientific research (molecular dynamics) and this language is exactly the sort of thing I've been looking for.
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.
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.
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 think Julia is the largest application of itself at the moment - the majority of functionality is written in the language itself. The time-to-repl is 2-4s depending on your os and setup. Taking package loading time in to account, it can be an issue, but there is a plan (and code) to address this soon.
Yes. There is a patch which provides static compilation support for the system image and should eliminate the startup time. However, the changes from 0.1 have been enormous already, so this will not be merged until 0.2 is tagged.
it's a JIT, so it's progressive compilation in some sense. BUT i certainly noticed that it seemed slower than python when starting a program. not java slow, but not instant.
As mentioned by the others posts, Julia-IPython ("IJulia") support is available. While this is very new, the fundamentals are solid enough that several people are planning to use it for courses this fall.
