I don’t use the Google search engine, which may be the reason that I did not found the critique given by Victor Zverovich and that of Dan Luu. Searching for “julia programming language” with Google on my computer shows their blog posts on the 3rd and the 5th ranking, respectively. With my daily search engine duckduckgo.com, I found them around the 35th and 100th position.
As for Zverovich’s post, I didn’t have the idea that he raised issues that are important to me. I have never used Matlab (maybe once I did something in Octave). I have used Fortran quite a lot. Julia’s syntax looks like that (at least loops, for instance), and I like it. So I can only disagree with the issue he has with the syntax.
Especially Luu has a couple of good points. Especially those that criticise behaviour of core developers is disturbing, but I always find it very difficult to judge those things.
I don’t quite understand what you are saying here. We all want to get things done. But when you don’t know how to do things, you have to ask, read the manual, or put in some other effort, don’t you?
Julia is a free software project. Things are likely to get more convenient, but it is unlikely that package authors will invest a lot of time in making their work suitable for users who want to invest near-0 effort. Maintaining interfaces like that is very costly and not very rewarding; it usually happens when someone pays for it (Matlab, of course, is a case in point).
I think that people frequently misunderstand free software communities. They are driven by contributors, who don’t just want to replace and improve on commercial or free alternatives per se. Unless they are financed by some company (eg like some Linux kernel contributors), they want better software primarily for themselves. For Julia, this is reflected in the famous “we are greedy” announcement.
I totally understand your point. From a country with very limited online resources, I spent a lot of time reading online materials that can help me. However, most of my students just want to get things done in the easiest way and never have to do it again…
I noticed that they prefer hard copy or published books instead of online resources, and they will never read it unless they pay for it.
For graduate students, the situation is better, but still they do not want to spend time learning programming by their own. That is why some legacy codes are used by many years.
I understand that some people do not like non-standard evaluation.
From a PL perspective, piping reduces efficiency and sometimes is unsafe. However, from a education perspective, it really saves me a lot of trouble. When I first came to U.S. , I noticed that students are taught to do math like this:
1+2 = 3 + 5 = 8*2 = 16
Basically, they think from left to right. If I teach them to program in the traditional inside-out way in my finance class, they feel it very difficult to look back to debug and there are too many brackets confusing them.
Since I am not a CS instructor, I do not have the luxury to expect students to write code in an elegant way. As long as they can get the correct answer, I am more than happy with that.
Agreed. After experimentation with Julia and writing a prototype recommendation engine in it a few years back (julia v0.3) I went back to R for my data analysis/statistics stuff and I’ll keep on using it for the coming years. Heck I might even use for number crunching deep learning & big data now since it now has wrappers to Spark and deep learning lib and has good parallelization mechanisms now both for single host & cluster/cloud.
After reading Luu’s post again, I decided that I cannot make an informed opinion about this (I also don’t know enough). Maybe much of his technical criticism is already solved or is not that important. As a Julia user who just started writing analyses of model output and simple simulation models, I can only say that my experience so far is very positive.
Yes, there appears to be a personal feud between Luu and a Julia developer. Though I don’t know, I assume that doesn’t impact his technical criticisms.
This kind of hagiography is really frustating in open source projects. At best, it convinces outsiders that a project’s bus factor is poor. At worst, it divides communities depending on each person’s patron saint. Let’s hope that it becomes less common.
Does anyone know what this means? I thought multiline comments are just enclosed by triple quotes but what exactly was the problem with the symbols?
The expression syntax is more reasonable, but there is still some unorthodox choice of operators, punctuators and the syntax for multiline comments that creates WTF moments every now and then (who has come up with this stuff: #= \ // $ ?)
I think it would be more constructive to provide an update and insights in a new blog article. Feedbacks welcome. Feel free to post your comments directly as well.
Great post! Really nice and clear. One thing I would change:
The fib function was then optimized using a LRU cache. As it’s deviating from a benchmark perspective (unless we do the same for Julia) there’s no comparison.
I would make this more clear to outsiders why. Basically say that at that point it’s a different algorithm, so of course it’s faster. And we could do the exact same change in Julia and it would be faster too, but what we’re benchmarking is how fast the language runs and not how fast the language runs on these kinds of operations. I just think it goes a little quick and, to someone who doesn’t know what’s going on, may think you just dismissed potential Numba/Cython optimizations.
A few comments:
Triple doublequotes """ are simply another way of making a string literal, and is almost the same as using single doublequotes ", except that you don’t need to use a \ to escape any " appearing within the string,
and some processing is done to remove indentation. #= and =# are used to mark off multi-line comments, the same as /* and */ in C/C++.
There were already multiple alternatives to @printf available when he wrote his blog, such as Lin Dahua’s Formatting package, or my own StringUtils package (which has been superceded by StringLiterals). You could mention that.
About unit testing, we also used FactCheck (you have a mispelling, FastCheck, twice in your blog), until most of it’s features were added to Base.Test, and development/maintenance on FactCheck seemed to stop, at which point we switched over to Base.Test.
What did you mean by saying there were 8,219 lines of Scheme, and 2,286 lines of Lisp?
There’s only FemtoLisp, which is an implementation/dialect of Scheme (that Jeff Bezanson wrote)
FemtoLisp is used for both the parsing (converting Julia text into an Expr), and for “lowering” (dealing with macros, etc).
Also, the C code and the C++ code are actually rather separate. FemtoLisp is written in C, as well as most of the low-level support for Julia (memory management, calling into C, etc).
C++ is used for the code that works with LLVM (that’s the one part of Julia I really having dug into yet)
