I used Julia for both a machine learning course and a neural networks course this past semester, and I really enjoyed the experience of developing in the language. I found it really a lot faster than python/numpy and a lot more sane than Matlab. Some key syntactical structures are also very purposefully kept similar to Matlab so it was very easy to translate code between the two, which is incredibly useful in scientific computing. I definitely recommend people check it out; however, I will warn any potential users that the run times of Julia programs right now (as of 0.3.x) are incredibly slow if you need to include any third party libraries. I understand they're working on this for a future release (maybe 0.4), but even including a simple plotting package in your code currently causes a 20-40 second overhead before your code actually starts running because the packages aren't precompiled.

Oh, and one more tip for OSX users wanting to try out Julia. You might want to just use the app bundle provided on the Julia homepage rather than compiling from the homebrew tap. I spent close to an hour waiting for all the dependencies to compile before giving up when I realized I don't want to be doing this every time it's updated.

For what it's worth, when building from source, the first time compile is the only one that takes an hour. After that, incremental updates are pretty quick since the only thing that usually changes is Julia itself, not the bucket load of source dependencies (LLVM, OpenBLAS, FFTW, GMP, etc.). Most devs pull rebuild Julia from source several times daily – this is the best way to stay bleeding edge (if that's what one wants). Even if one doesn't want to live on the bleeding edge, checking out the release-0.3 branch and building that from source is also an option. That said, the binaries are also a good way to get Julia.

Good tip! I've had a number of issues with the Homebrew tap. I've yet to dive in head first. I've been playing around with Juno [1] and like it a lot so far.

I hope we'll see more advanced tutorials appear for Julia soon. I'm quite comfortable with using C++ now for all my scientific computing code, but it really isn't "nice" to work with. It would be nice if there was something like SciPy [2] for Julia, to get researchers going quickly.

[1] http://junolab.org/

[2] http://www.scipy.org/

For a while now I've been interested in learning more about Julia, though not exactly sure yet what use-case I have for it. I guess I wouldn't know until I do study the language enough to figure it out.

This tutorial looks promising, building knowledge carefully but not too much "hand holding", like it's for programmers experienced in other languages. Got part of the way though it so far, obviously not a "one-shot" kind of exercise.

My only complaint is the same one I make with many other tutorials of this kind. I find it very annoying when some feature or function is used in an example, but the function comes "out of the blue", not defined or explained, as though the reader is supposed to magically divine its meaning or definition.

In this case, everything goes along swimmingly until encountering the function/method "repr(a)" in "Arrays" examples. I dutifully spend several minutes tracking it down, and what do you know, basically the same as (->string ...) in Scheme (i.e., object->string representation).

I'm not giving up on Julia. I'll carry on from that point when I return to the site. But really, IMO every newly introduced term/function/feature should be defined so that the example can actually be completely understood.

Otherwise there's a substantial risk of losing readers who will not so likely be motivated to keep trying to figure it out.

</end of minor rant mode>

You can say ?symbol in the prompt and it will tell you what it is

    help?> repr
    Base.repr(x)
    
       Create a string from any value using the "showall" function.

I don't do any scientific computing, as such I have zero use cases for Julia.

However as language geek, I do follow its development.

It is quite interesting to see another dynamic language in the same footsteps of Lisp dialects and Dylan, where performance, ability to compile to native code and simple FFI are considered important features to be part of the main implementation.

Really looking for Julia becomes widely used.

I also don't have a lot of need for scientific computing; Julia has the potential to be a really compelling replacement for Python for general purpose scripting.

I do wonder if the 1 based indexing puts off a lot of developers. I have no issue with it but it seems to come up in most threads discussing Julia, here and on Reddit.

Personally I think it stems from a C influenced culture in terms of array indexing.

People from my age remember programming languages where you index from one, can select the base index or use enumerations as indexes.

Tooling, performance and libraries are much more important than base indexes.

Then again, I favored those C alternatives back when C wasn't an option at all. So I am biased.

I found it highly annoying, but understand why its there.

But can't you do a[begin] to reach the first item in a julia array? That should really abstract it away no?

Great post! This is by far the best way to learn a language for people who can already program in another language.