News for hackers. Stuff that matters.
Re:Julia is awesome, but.. by KenoFischer on Monday December 29, 2014 @10:33AM (#8810146)
This is very fair criticism. Julia has yet to make the full transition from research project to production language. Having seen Julia evolve over the past 2+ years, I feel like stability and test coverage have improved a lot and I expect them to improve further.

I fully agree on the need for more testing. We've been trying to make sure that new functionality and all issues reported come with tests where possible and I actually think we've been making progress on that front (and especially compared to two years ago), but we need to do a lot more of this. For a significant number of the core contributors (myself included), Julia is probably the first big project we're working on and we're still learning proper release engineering and making software for a large number of users.

That said, I think we've been pretty good about keeping master functional recently and I don't remember the last time I pulled from master and had something break (I think the travis status analysis is misleading here, because it probably includes development branches as well as instances where the CI system itself is failing - either because travis is down, or because the servers for dependencies are down etc). I also don't think that we've ever left master broken for days at a time when there was an easy fix available (of course bugs that come up and you don't know how to fix can always happen).

On that topic though, I think we have room for improvement. I've been thinking about moving to a pre-commit CI system (you push to a branch and the CI system merges once everything's green), especially now that we have CI coverage for all 3 supported platforms. I'll bring that up on the mailing list.

So much for the Julia core. Packages are a different issue and I agree that we have a problem with package quality. That are a few very high quality packages (I'm thinking e.g. Color and Distributions) and a long tail of packages of varying quality. Iain has been doing great work on this front with http://pkg.julialang.org/pulse.html and making sure that packages keep up with changes in julia and at least pass their own test suite, but there's obviously a lot of work to be done there.

The good thing is though that since these packages are completely decoupled from Julia core, this can be easily parallelized. One of the advantages of Julia is that the core is pretty small (admittedly bigger now than it should be and we need to split some stuff out) and it's in general pretty easy to look at the code which hopefully makes it easy hack on packages. Making high quality packages requires a lot of time and work and since Julia is such a young language, the ecosystem is still immature.

If you have thoughts on what we can do to improve package quality or make things easier on package developers, please let us know, we'd love to hear them.

Finally, I also would like to ask to please, please file bug reports for things that don't work the way you expect them to or for any bugs you encounter. One of the things mentioned in the OP was the REPL rewrite (which I worked on). The original REPL was a messy readline based hack, which really needed to be replaced. Admittedly, readline has a lot of features and I originally only implemented the ones that were part of my workflow, but I fully expected people to file issues for any features they were missing (and they did) and I and others quickly implemented lots of features (including quite a number not present in the original rewrite). Of the REPL issues currently open, I can see only one that may have worked with the original REPL (emacs keybindings). In any case, if you're missing features in the REPL please file an issue.

I'll end with my general disclaimer that while Julia has a lot to offer, it is not yet a polished system and I don't yet recommend using it if that's the experience you want.

Sorry for making this so long

TL;DR I agree, Base needs more testing, but I think we've been making progress on that. Another big issue is package quality, which I'm not sure how to fix. If you encounter bugs please file issues.

Re:Julia is awesome, but.. by wbhart on Monday December 29, 2014 @11:13AM (#8810327)
The package manager in Julia is great, but the process of making a package needs much better documentation.

It looks like Bindeps is the intended way of building packages that have external dependencies, but last time I checked the "documentation" for bindeps was another Julia package called Cairo, which apparently did a good job.

The other problem is that when Googling around to find the standard way of putting together packages, almost all the results that come back are list posts or things from the issue tracker which tell you the old way of doing things (which no longer works).

Things like how to build things differently for Windows, Linux, OSX, Unix, how to deal with paths, how to use the OpenSUSE binary production system, etc., all need documentation, with examples.

Also needed is documentation on linking against external libraries that have their own dependencies. Where should libraries be canonically installed. How does the linker resolve dependencies (this is especially difficult to work out on Windows).

Including all the .h files for Julia's own shared library dependencies in the repo would also be useful, along with documentation of which versions of external libraries Julia currently uses.

I also find the documentation on how to peg to a commit or tag difficult to understand, as is the documentation on the path to becoming an official Julia package, with explicit examples of what needs to be done at each step.

Finally, I find it annoying that you can do Pkg.update("Mypkg") and Pkg.build("Mypkg") but not Pkg.test("Mypkg") (or is it the other way around, I always forget). One should be able to selectively update, build and test any particular package, without having to do so for every package you currently have installed.

Some of my comments might be out-of-date by now. I'm simply trying to recall some of the issues I had with building a package when I last put effort into that part of my development cycle.

Re:Julia is awesome, but.. by wallnuss on Monday December 29, 2014 @12:01PM (#8810579)
You cannot do Pkg.update("MyPackage", but you are able to do Pkg.build("MyPackage") and Pkg.test("MyPackage").

Pkg.update() is currently designed to update the local METADATA snapshot and then update all packages. You can also update one package at a time manually with Pkg.checkout.

Re:Julia is awesome, but.. by robrenaud on Monday December 29, 2014 @01:12PM (#8810964)
From personal experience as a software engineer at Google, precommit with a force override fall back is great. I worked here before we had it and after we had it, and it makes things way better. master should stay clean, and the pre-commit approach gets you pretty far down that road.

It also helps to have a culture of quickly rolling back breaking changes when they do slip through.

Re:Julia is awesome, but.. by plinkplonk on Monday December 29, 2014 @01:41PM (#8811094)
I second the move to a precommit based system. Getting a rock solid build is low hanging fruit for most projects, And getting to that point is usually just straightforward engineering. That said, this is a young project, and probably just needs more developer bandwidth to fix these minor glitches.
Re:Julia is awesome, but.. by StefanKarpinski on Monday December 29, 2014 @03:31PM (#8811611)
The problem with Travis failures is not that people aren't running the tests, it's that Julia depends on a lot of complex, finicky software [1], much of which is unusually sensitive to platform-specific differences and even differences between specific CPUs and VMs. This makes keeping builds green across the board pretty challenging. But anyone who has tried to build a fully working numerical stack like the one Julia ships with, can attest that it's non-trivial and changes that work on one machine may break things elsewhere.

[1] https://github.com/JuliaLang/julia#required-build-tools-and-...

Re:Julia is awesome, but.. by plinkplonk on Tuesday December 30, 2014 @05:32AM (#8814016)
I understand, but having so many dependencies is probably all the more reason why you need very good test coverage and a build/deploy that keeps the trunk clean, so nothing gets released without all three (or however many) platforms all build clean.

Not to armchair quarterback, I know it is a hard thing to get there and you guys are all busy. Just my 2 cents.

(And I think Julia is bloody brilliant, fwiw)

Re:Julia is awesome, but.. by IndianAstronaut on Monday December 29, 2014 @03:56PM (#8811723)
In contrast, getting R up and running is very easy. I can easily set up multiple R versions on my machine. If I want to emulate a library environment on another machine, I just need to copy the folder over to that machine.
Re:Julia is awesome, but.. by grayclhn on Monday December 29, 2014 @10:09PM (#8813119)
This isn't quite true. I know of several R packages that I've had to build from source on Linux and I'd be worried about installing on windows (Combinations and Cranvas come to mind).

Generally the packages that aim for higher performance are more difficult to install, which makes sense.

Combinations: http://www.omegahat.org/Combinations/

Cranvas: https://github.com/ggobi/cranvas

edit: and if, god forbid, cran kicks off one of the packages you're using or an upstream package for a package you're using, then you've got to track it down and install it on your own. (tikzDevice is the one I'm thinking of.)

Re:Julia is awesome, but.. by idunning on Monday December 29, 2014 @07:01PM (#8812557)
Are you talking about compiling R from source, including all dependencies and high-performance BLAS, LAPACK, FFT, ARPACK, etc. libraries? If not, you are comparing apples to oranges.
Re:Julia is awesome, but.. by IndianAstronaut on Monday December 29, 2014 @08:02PM (#8812763)
Yes. You can get multiple versions easily on the same machine and run them from that location. It's also easy to point rstudio to that instance. All the libraries install in the same location as well.
Re:Julia is awesome, but.. by StefanKarpinski on Monday December 29, 2014 @09:18PM (#8812970)
R ships with the reference BLAS which is 4x slower than OpenBLAS even on modestly sized problems. If you value portability over performance, I guess that's an ok choice, but we want to make sure that Julia ships with the best open source BLAS available. If that means putting up with the occasional broken builds on Travis, I think it's worth it. OpenBLAS is just one example – R seems to have consistently chosen portability over performance for their libraries. That's a viable choice, but it's not the one we've made.
Re:Julia is awesome, but.. by KenoFischer on Monday December 29, 2014 @03:45PM (#8811677)
Since I can't edit anymore, Dan pointed out to me that he did not include development branches in his Travis analysis.