News for hackers. Stuff that matters.
Re:Why Julia by ritoune on Saturday February 23, 2019 @09:58AM (#19233554)
The main issue I encountered as a Julia user is that multiple dispatch doesn't scale very well.

When you start building out a project, it's easy to keep track and debug if multiple dispatch starts failing (i.e. <any> type starts spreading everywhere and Julia slows to Python like speeds).

In medium-to-large projects, it becomes extremely cumbersome to manage this. It's doable, but adds a layer of complexity management to projects that simply doesn't exist in strictly typed or pure scripting languages.

Of course, you can just decide to explicitly type everything - but the issue here again is the lack of enforcement.

In a nutshell: Julia is great when you're a grad student working mostly by yourself on small scale projects! But not so great in prod.

And there's really no problem with that; that's who the language was designed for!

Re:Why Julia by ethelward on Saturday February 23, 2019 @10:14AM (#19233635)
> In a nutshell: Julia is great when you're a grad student working mostly by yourself on small scale projects! But not so great in prod.

Some people would disagree with that

https://juliacomputing.com/case-studies/celeste.html

Re:Why Julia by ritoune on Saturday February 23, 2019 @10:53AM (#19233831)
Sorry - I didn't mean to sound so negative! I'm very well aware of all the large Julia use cases and they're often great applications of the language.

I would also argue that the large open source Julia packages are also great examples of Julia "in prod".

Just highlighting what I think is a significant con in a language with many pros!

Re:Why Julia by antpls on Saturday February 23, 2019 @04:06PM (#19235473)
This was published on their own website, it is therefore biased toward a good perception of them. It doesn't seem to be a fair and independent review to help build an opinion.
Re:Why Julia by ethelward on Sunday February 24, 2019 @06:45AM (#19238205)
And these were not published on their website:

https://arxiv.org/pdf/1801.10277.pdf

http://proceedings.mlr.press/v37/regier15.pdf

https://arxiv.org/pdf/1803.00113.pdf

I had to go so far as to read the project Github page to find them.

Re:Why Julia by antpls on Sunday February 24, 2019 @09:11AM (#19238608)
In all those papers, there at least one member of the team in the author list, or a member of a partner organization (Intel, Lawrence Berkeley National Laboratory, etc). I wouldn't call them fair independent reviews of the language.
Re:Why Julia by ethelward on Monday February 25, 2019 @04:38AM (#19244311)
Are you really complaining that the people writing about the tool are the ones developing it?

Whose opinion do you want, the Pope? Would a divine sanction be enough for you?

Re:Why Julia by ummonk on Saturday February 23, 2019 @10:59AM (#19233867)
Yeah, my biggest want for Julia 2.0 would be a built-in static type analyzer.
Re:Why Julia by oxinabox on Saturday February 23, 2019 @05:10PM (#19235775)
That is neither a breaking change, (and thus could come in 1.3) Nor something that needs to be baked in. (thus could be in a package)
Re:Why Julia by m4x on Sunday February 24, 2019 @04:27PM (#19240724)
I think multiple dispatch will scale perfectly fine for large projects when it has better IDE support.

There's no reason Juno or any other IDE couldn't display the output of a static analyser inline, or allow you to command-click a function call to go to the site of the exact function being called, or show a list of alternatives, and so on.

Give Julia and its IDEs a few years to improve and you might find it much better suited to large projects. I wouldn't consider Java any good for large projects either, if it didn't have the excellent IDE support it now enjoys.

Re:Why Julia by nicoburns on Saturday February 23, 2019 @09:15PM (#19236733)
The optional typing seems like the perfect solution to this... skip explicit typing for small scale projects, but make sure you add it for production...
Re:Why Julia by byt143 on Sunday February 24, 2019 @04:50PM (#19240826)
Both cassette based performance linting and static type checking will solve this problem. There are already the beginnings of the tooling being formed.