
A review of the Julia language (2014) - patagonia
https://danluu.com/julialang/
======
czep
Julia holds a lot of promise: the next 5 years will determine whether it can
deliver on its quest to solve the two language problem.

Over the past few weeks I've been evaluating Julia as a potential R
replacement. IMO, it's definitely not there yet. I've run into bugs, crashes,
hangs, sluggish performance, packages that won't load in 1.0, a clunky REPL,
and a lot of code that I can't trust has been as well peer reviewed as what's
in Base R. It'll take me a couple months but I plan to write a blog post on my
experience, and I'm no Dan Luu ;)

That said I like the design of Julia, and the mission or promise as I call it
could eventually make Julia an R replacement (as well as a replacement for
lots of other languages). I started using R in 2001-ish, and at the time I
remember thinking no way would I switch to R from SAS. Today I laugh at that,
but that's the difference that 15 years will make. Julia is still very young.
It's advantage is the modern design. R is entrenched and robust, but let's
face it, it's design is ancient, rooted in the Fortran-and-card-punch era, and
there are things (eg. multithreaded) it will never do.

Julia is at a crossroads: the core developers are eager to listen to the
community. Whether the devs can maintain grasp of their vision while still
delivering what the community wants is yet to be seen. They're being pulled in
a thousand different directions, based on everyone's desire for what they want
out of Julia. This could end up a disaster if the devs don't stick to their
vision. Even though it's not good enough to replace R for my daily work right
now, I plan to keep using Julia and contributing, because in 5, 10, 15 years,
perhaps I will feel about R the way I feel about SAS today.

~~~
mkborregaard
An important thing that many people fail to realise is that Julia-1.0 came as
a surprise to package authors as well, and thus the first month of the the
release has been a scramble to get everything working on 1.0. Unfortunately
the pre-1.0 package manager did not have good facilities for upper bounding
versions - so essentially everybody's packages would install on 1.0 but be
broken.

At exactly the same time, a lot of people thought "hey, 1.0 time to check out
this new language", and would experience all those crashes.

Doing a review of Julia based on the experience in the first month after 1.0
will be grossly misleading. I've used the language progressively more for the
last 3 years, and also teach a university R course, so I have some experience
to base that claim on.

~~~
czep
> Doing a review of Julia based on the experience in the first month after 1.0
> will be grossly misleading.

This is definitely a fair point and a main reason I am not rushing to judgment
after trying Julia for just a few weeks. I like the language already, and
fully realize there is a lot of hard work going on among package maintainers
to adjust to 1.0. My main advice to anyone trying Julia is to take the long
view. It's still very young so look past the rough edges to its potential.

------
danysdragons
The article argues that while the language is way cool in principle, the
current implementation is bug-ridden and has poor error-handling. But as the
HN title acknowledges, the article was written in 2014, when the Julia version
was only 0.4. Since then it's been four years, and Julia only recently hit
1.0. It would be much more interesting to see an article discussing the
current state of the language.

~~~
eigenspace
I've been using Julia seriously for the last year and I'm absolutely loving
it. The language is beatiful, elegant and _fast_ and the community has been
nothing but friendly, helpful and welcoming to me.

I think its a real shame this out of date grievance article is being dredged
up again giving people a myopic view of what Julia 0.4 may have been like in
2014 when its now 2018 and we have v1.0.

------
shele
It is the year 2048. A hacker news veteran presses enter to fulfill her duty
and reposts the sad story about Dan Luu and the Julia community. A greyed
Stefan Karpinski tries to object but his statement disappears behind thousands
of Dijkstra postings. In the distance the voice of the zealots, chanting
1-based, 1-based...

~~~
ModernMech
I don't understand this. Please elaborate.

~~~
czep
In math when we write a sum, we say "sum from i = 1 to n", not "sum from i = 0
to n-1".

Zero-based indexing of arrays makes sense in a language like C where arrays
are just pointers and offsets are determined with arithmetic on pointer
addresses in memory. This is why we are trained to write code like "for (i =
0; i < n; i++)". But in Julia where one of the stated purposes is to be able
to write code that looks like formulae, it is far more natural to use one-
based indexing.

~~~
ModernMech
Sure I get that. MATLAB and FORTRAN also use 1 based indexing, so that's
nothing new. People have been arguing about that since 1950 :P I just didn't
understand the context of the post.

------
FranzFerdiNaN
I have really no clue why a post from 2014, discussing the language at 0.4, is
being posted again and also upvoted.

~~~
swdunlop
The only value I see is reminding people how much Julia has improved since
2014.

~~~
ModernMech
There's a lot of value here for anyone who does language design and
development. It's important to see the challenges early language projects
face, how users respond to them, and how the community responds in turn. If
you examine this piece not from a perspective of the language wars or a
language user, but from a perspective of "What can this tell us about what
challenges early languages face" then this is a very good article. At its
core, this article is about someone who was interested in a language, used it
enough to find many bugs, found the motivation to write a blog post about it,
and the community and devs responded in good and not so good ways.

For the right reader (early-stage language devs) this is a great resource.
It's like an archaeologist uncovering a 10,000 year old pot. Sure it's not
relevant to most users of pots today, but makers of pots could maybe learn
something from it.

------
npr11
Beyond the state of the Julia Language (which I am excited to try out since
1.0), the core community comes off really badly in this post, and the previous
follow-up discussion on HN [1], and julia-users group [2].

[1]
[https://news.ycombinator.com/item?id=8809422](https://news.ycombinator.com/item?id=8809422)
[2] [https://groups.google.com/forum/#!topic/julia-
users/GyH8nhEx...](https://groups.google.com/forum/#!topic/julia-
users/GyH8nhExY9I)

~~~
attractivechaos
IMHO, one of the worst things Julia had done was to unnecessarily break so
many backward compatibilities (e.g. renaming shift!() to popfirst!() – who
cares? and how many user code this will break!). As a result, a great portion,
if not the majority, of Julia tutorials online are not applicable to the
latest version any more. This leads to a lot of headaches when you learn
Julia. I know v1.0 is supposed to be stable, but their track of record makes
me doubt. I will see what they do to v1.1 and then decide if it is worth
learning.

~~~
stabbles
Julia uses semantic versioning now, so there's a guarantee there will be no
breaking changes.

~~~
Chyzwar
They can make breaking changes in every major release. Angular 2,4,5,6
versions were released in the span of just two years.

------
FridgeSeal
This is hella outdated.

The language has changed (for the better) soo much since 2014.

I'm sure there's more up-to-date reviews that could be more useful...

~~~
deathtrader666
Could you please point to some newer reviews that you trust? I'm trying to get
a sense for myself whether I should invest my time learning Python or Julia.

~~~
nnq
> Python or Julia

...replace that "or" with an "and". Python is unavoidable, and it makes no
sense not to become proficient at it unless you already know another language
usable also as a "systems scripting language" (eg. Ruby or Perl).

~~~
ced
Depends what you do. In science, lots of people learn only Matlab, and Julia
can be a solid/superior replacement, depending on the problem space.

------
FlorianRappl
I would really love to see what happened since the article, since I,
personally, stopped using Julia around the same time (unrelated to the
article) and only followed the announcements (e.g., of hitting the 1.0
milestone). I would love to know if the outside view ("it improved / matured a
lot") is the true story.

~~~
ChrisRackauckas
Julia seems to be quite different. I will say "seems" since it can be hard to
find someone who's been around since v0.4: most people joined the community
long after. 2016 had a "third generation" of Julia developers join in, and
there's a been a boom in the package ecosystem around that with high retention
rates from GSoC.

------
pieterr
Previous discussion on HN:

[https://news.ycombinator.com/item?id=8809422](https://news.ycombinator.com/item?id=8809422)

