Comment by eigenspace | Hacker News Reader

Comment by eigenspace | Hacker News Reader

Julia is such a great language, it's what really made me care about end enjoy programming. I think it's the modern language which has taken the most lessons from lisps, and has come up with some great ideas of its own too.

There's lots to like, but I think the thing I love most about it and find it so interesting is that it's almost uniquely good at taking a piece of code and transforming it's meaning in various ways, and has so many tools for doing so. There's

  * Multiple dispatch allowing very flexible writing of generic code, and multiple dispatch isn't some tacked on, opt-in extra. Every function in the language is overloadable, and there's no performance penalty for using multiple dispatch

  * Parametric typing allows for a huge amount of abstraction over common 'base' types

  * Lispy macros let you do metaprogramming that changes the meaning of a piece of syntax

  * Generated functions let you intervene at compile time and lets you essentially take over the compilation pipeline and customize the code generation for any given input type signature

  * The abstract interpreter interface which lets one essentially take over the compiler and customize your code generation and analysis passes to your heart's content. This is used for instance to support GPUs and automatic differentiation as package offerings.

There's understandably been a focus on speed, but what I really like about Julia is being able to write clear code: it has a lot of the flexibility and expressiveness that I like in Lisps, but with better numerical libraries than most Lisps/Schemes, and I really like prototyping algorithms in it. To me (an applied mathematician) it is just a nice tool for thinking in. Not having to compromise too much on speed is a big bonus.

It was a great idea for a language. In practice though,it's hard to recommend. Great pet project for some mit professors to make a bunch of side money on top of their salaries though. Everyone else riding it is pretty much trying to niche their career rather then build something people can rely on unfortunately. It's the most unstable language I've ever used. In production I watched companies spend millions of dollars, not large companies, dealing with that aspect of it. The ecosystem surrounding it, though it's old enough, is also incredibly weak.

It's a shame. So hard to recommend it to anyone outside of an academic environment.

This depends a lot on what you're trying to do with it. There have been companies which did what you described, but there's also companies happily using it.

If you reach into unstable language internals, yes there is a lot of churn. If you use public language interfaces, the language has been extremely stable for a long time.

The ecosystem quality and quantity depends a lot on what you're trying to do. If you're far away from numerics, then yeah, you will struggle a lot more. E.g. I wouldn't want to do web-dev in julia, but if your software product involves needing to solve an ODE, or a lot of linear algebra, I wouldn't want to be anywhere else.

Not griping about the internals. More like breaking changes, weird issues with basic transitive dependencies breaking after a minor version bump to the language. Gave me, and others on the team, the impression that the whole thing was held together with bubblegum and toothpicks.

The ode stuff is cool, but when we reached for it none of the demos ran on recent versions. It was almost like the groups working on it either intentionally made it so you couldn't keep up with them or that again everything was built on a bed of sand.

I agree writing linear algebra in Julia is clean. That said, the cost for adding a few "." Chars or calling a library in any other language far outweighed the costs for trying to buy into the language itself.

I didn't even know you could do web dev in Julia. I don't want to know what that looks like.

> More like breaking changes

That certainly has not been my experience with the language since 1.0

> weird issues with basic transitive dependencies breaking after a minor version bump to the language.

Not sure what exactly this is referring to, but I suspect it was some bugs that happened when some stdlib packages were taken out of the sysimage and started being treated more like regular packages which are pre-installed.

For a couple minor versions, if you instantiated an manifest from a previous version that used some stdlibs, it could error out. That was indeed unfortunate and IMO should not have been released as such, but it's since been fixed.

I will point out though that officially, you are not supposed to use the same manifest across versions.

> didn't even know you could do web dev in Julia. I don't want to know what that looks like.

There's actually some rather cool stuff happening in that space, but yeah it's early days.

Yea this wasn't user error which is the common gaslight trope from the Julia community. Yes some of these instances post dated 1.0 . Yes the average person is sick of being told there's nothing wrong with the technology when there's been a serious track record of it being a disaster. For companies an expensive one.

It's really not early days. The language is about 15 years old. That excuse gets really tired.

It's crazy to me how every person posting positively about Julia has the same tactics. They don't change year after year. They try to draw people in only to find it's a Trainwreck or a waste of time.

I just hope my comments save a start up a few million dollars or a curious hobbyist 5 months of their free time.

Not trying to gaslight you. Especially if you were hitting that issue with the stdlibs, as I said, I don't think we should have allowed a release to go out with that problem. It was treated as bug though and fixed (though it also took longer than hoped).

The manifest thing is a good example of a hard situation. You have a file format that's not designed to be portable across versions, but the usage pattern around it heavily encourages that, so of course it gets used across versions and bad stuff happens. I'm sure theres also some other examples like this one can pull up.

Of course there's cases where we should be doing better. I'm just also saying that this isn't the only experience out there, and the negative experience you're reporting isn't my experience.

> It's really not early days. The language is about 15 years old. That excuse gets really tired.

Please don't twist my words. I was responding to what you said about webdev, and I said there was some interesting things happening in that space, but still early days. I was explicitly referring to the webdev ecosystem being immature, not the language.

I love multiple dispatch and I wish more languages had it

It's a really nice feature. That said, I do think in the earlier days, the community did get a bit too enthusiastic about it, and used it in a lot of places in the ecosystem that didn't make so much sense.

I think things have come down to a much more reasonable place though now.

Reply on news.ycombinator.com