

First impressions using Julia - andrewcooke
http://acooke.org/cute/Firstimpre0.html

======
Xcelerate
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.

~~~
ihnorton
_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).

------
guelo
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.

    
    
      elif: sh, python
      elseif: PHP, Modula-2, Dylan, Eiffel, Oz, Matlab, Julia
      elsif: Perl, Ruby, Ada, Modula-3, Tcl, 
      else if: Awk, B, C, C#, C++, Java, JavaScript, Pike, YCP, OCaml, Delphi, Pascal

~~~
caioariede
Nimrod ([http://nimrod-code.org/](http://nimrod-code.org/)) also uses elif

------
wikkiwa
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.

------
marshray
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](http://julialang.org/Graphs.jl/interface.html)

~~~
rspeer
My impression of Julia is it's what happens when Lisp people decide Python got
some things right, and vice versa.

~~~
CatMtKing
Still hate the 1-based indexing, but oh well.

~~~
marshray
After doing little Lua I found that it was possible to mostly get used to.

------
caioariede
It's nice that the final code looks clean and very readable. I would suggest
you to give Nimrod ([http://nimrod-code.org/](http://nimrod-code.org/)) a try
too.

------
marshray
Has anyone tried a large-ish application? What's the startup time like?

I'm a little concerned because it seems to be doing a fully optimizing
recompile on every invocation.

~~~
ihnorton
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.

~~~
marshray
Is the 2-4s for non-REPL ordinary scripts too?

~~~
ihnorton
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.

~~~
marshray
Awesome!

------
michaelgrosner2
I've been spoiled by the IPython Notebook. Once Julia has an equivalent/full
support of the IPyNB and a Pandas equivalent, I'm all in on Julia.

~~~
jamii
[https://github.com/JuliaLang/IJulia.jl](https://github.com/JuliaLang/IJulia.jl)

