Comment by Darmani | Hacker News Reader

Comment by Darmani | Hacker News Reader

Parent Full thread

I've worked in about 40 languages and have a Ph. D. in the subject. Every language has problems, some I like, some I'm not fond of

There is only one language that I have an active hatred for, and that is Julia.

Imagine you try to move a definition from one file to another. Sounds like a trivial piece of organization, right?

In Julia, this is a hard problem, and you can wind up getting crashes deep in someone else's code.

The reason is that this causes modules that don't import the new file to have different implementations of the same generic function in scope. Julia features the ability to run libraries on data types they were never designed for. But unlike civilized languages such as C++, this is done by randomly overriding a bunch of functions to do things they were not designed to do, and then hoping the library uses them in a way that produces the result you want. There is no way to guarantee this without reading the library in detail. Also no kind of semantic versioning that can tell you when the library has a breaking change or not, as almost any kind of change becomes a potentially-breaking change when you code like this.

This is a problem unique to Julia.

I brought up to the Julia creators that methods of the same interface should share common properties. This is a very basic principle of generic programming.

One of them responded with personal insults.

I'm not the only one with such experiences. Dan Luu wrote this piece 10 years ago, but the appendix shows the concerns have not been addressed: https://danluu.com/julialang/

It is discouraged to override internal internal functions, hence, one often only needs to monitor the public API changes of packages as in every other programming language. Updates for packages in my experience rarely had broke stuff like that. Updates in Base somrimes can cause issues like that, but those are thoroughly tested on most popular registered packages before a new Julia version is released.

Interfaces could be good as intermediaries and it is always great to hear JuliaCon talks every year on the best ways to implement them.

> Imagine you try to move a definition from one file to another. Sounds like a trivial piece of organization, right?

In my experience it’s most trivial. I guess your pain points may have come by making each file as a module and then adding methods for your own types in different module and then moving things around is error prone. The remedy here sometimes is to not make internal modules. However the best solution here is to write integration tests which is a good software development practice anyway.

So

In Julia, the (+) function is commonly overloaded

The [] is as well. For things that have no shared interface. (E.g.: Int64[1][1] contains two calls to the [] generic function, which have no interface in common.)

Plenty of definitions of (+) are not commutative. E.g.: for strings.

There is some package which uses the (+) generic function internally, meant to be used on numbers. You call it instead with some kind of symbolic expression type. And it just works. Yay! This is the kind of stuff Julia afficcionados preach.

Then suddenly the package gets updated so that it uses (+) in a way which assumes commutativity.

Your code breaks.

In your world, how would you be notified of a change that some internal use of the (+) function now assumes commutativity?

Or when Julia afficionados preach the amazingness of being able to just throw a differential operator or matrix or symbolic whatever in a place, are they just overselling something and should stop?

I don't quite understand what your issues were, I don't have any with the current module system https://docs.julialang.org/en/v1/manual/modules/

Can you provide some concrete examples of that issues existing today?

I had a quick skim of the link you gave -- it looks to be the same as it was 6 years ago when I experienced this issue.

So basically:

Generic function F is defined in file A, and has a method definition DEF in file B.

File C imports files A and B, and then calls function G that internally uses generic function F. Somewhere internally, it winds up running F with method definition DEF.

You move DEF to file D, but don't update the imports of file B.

When file B calls G, it calls F with some default implementation instead of DEF, and then you get an error from function G.

Some details here might be wrong over how exactly to imports need to be set up, as I haven't used Julia being traumatized by it 6 years ago, but that's basically it.

Well, with generic programming constructs you have more freedom, and with more freedom you have more ways to shoot yourself in the foot. I don't think Julia has some illogical or inconsistent design decisions of its module system. In fact, it's better than many other because the order in which you import modules doesn't matter.

I guess you had a bad experience, but this hasn’t been an issue for me using it for many years now.

Lol is this meant to be an ironic comment?

Reply on news.ycombinator.com