Julia 0.6 is out | Hacker News Reader

Julia 0.6 is out

github.com

88 pointsceyhunkazel31 comments

Julia is becoming too complicated for an average data scientist like me to master. It is not that much easier than C++ (which I know some). Considering it wants to attract people with Matlab background... I think it kind of defeats the purpose.

Being complicated and needing to care about the complications are different. For example, I use Julia as a fast, pseudo-Matlab desk calculator and haven't bothered to read about the type system [1] (I think I read a "so you're coming from Matlab" style cheat sheet). Maybe someday, but until then it sorta just works as you would expect.

[1]: The other day I did spend some time figuring out how to do Pkg.add("SQLite").

> Being complicated and needing to care about the complications are different.

I used to think that but changed my mind when it comes to programming languages. Mainly because once complexity is there, unless it's just a single developer or very tightly controlled / peer reviewed development practice, different contributors will use various subsets of features of the language and so you still have to know all the complex edge cases because you might have to read code. And arguably code is read more than written.

Maybe I'll run into that, but like I just went digging into some packages to see if I could get myself lost, and instead I learned that Julia can work on raw pointers, and found a cool raytracer that seems pretty readable in the CSG package:

https://github.com/JuliaDB/PostgreSQL.jl/blob/master/src/dbi... https://github.com/jtramm/ConstructiveSolidGeometry.jl/blob/...

How so?

The list of BREAKING CHANGES still keeps me away from doing more in Julia right now.

https://github.com/JuliaLang/julia/blob/release-0.6/NEWS.md#...

Yep, they stated version 1.0 will be the one where they stabilized.

Likewise Rust is like this for the language. Their standard library iirc were still developing?

So it suck in term of wanting something stable but at the same time they need people using their language.

I think the upside is there are tons of stuff you can contributes including the small stuff.

No, Rust went 1.0 a while ago. They will not make breaking changes to the language until a hypothetical 2.0 release, which at the moment they are not considering.

Of course the standard library changes; it's not a dead language.

New features, including new functions in the standard library, are marked 'unstable' when they are introduced. Unstable features have to be explicitly requested, indicating that the programmer is aware that their functionality may change before they're stabilized.

There is an important point here, which is that even if you've been stable for a while (two years for Rust) and even if you try to get that message out (some people on HN think there are too many posts about Rust), it can take a very long time for broad perception to catch up with reality.

That's not a value judgement on those who didn't know; cache invalidation is a hard problem. But it's an interesting facet of languages that plays out in a number of ways. See the link to Dan Luu's post from forever ago, posted numerous times in this thread as another example.

I'm not sure if Rust is a proper comparison, as the standard library for a language for scientific and technical computing is much larger than a language for systems programming: you want a vast vocabulary to deal with matrices as opposed to a minimalist set of orthogonal features for systems programming. Another consideration: with Julia, it aims to be both a full-featured programming language (with a type system and support for metaprogramming for library developers), as well as approachable enough for a scientist to pick up.

Well, yes, so maybe 0.x language specifications are not for you. That's not a problem. Pick your battles.

Not sure why this is being downvoted. As far as I was aware, the point of 0.x language specs was to allow for breaking changes and rapid language development before stable 1.0+ releases. Is there something that I am missing here? I'm not very familiar with Julia, maybe they are handling it differently?

Yes, I'm kind of curious about the down votes. Not voting at all, sure I get that. But hey, 0.x language spec is communicating up front that there is turbulence ahead, it's just good expectations setting. And as a user, there are times to avoid turbulence, and times to recognize when turbulence is simply the price you pay in return for the benefits of a tool that brings new capabilities. But then it is an ROI question. I totally get that 0.6 Julia may not have ROI for some people. But complaining about a 0.6 language spec having breaking changes.... that's like saying: "Hey, you advertised this candy bar as tasting like chocolate, but I prefer peanuts. I don't like it." Ummmm, yeah....

Perhaps because all I said was that there are still long list of breaking changes is keeping me from doing more with Julia.

I don't find that meaning I am battling anything, just I'm waiting till 1.0

Surprisingly all of my v0.5 code runs on v0.6.

Julia Computing announced its seed round yesterday[1], hoping we can see some additional velocity here.

[1]https://juliacomputing.com/press/2017/06/19/funding.html

The investing VC's thoughts - "Deconstructing the Near Perfect Deal"

https://hackernoon.com/deconstructing-the-near-perfect-deal-...

Does anyone know when Julia 1.0 will be out?

I believe 0.6 was the last 0.x release before 1.0 but that may have changed. At this time, the 1.0 milestone hasn't been assigned a due date [0].

[0] https://github.com/JuliaLang/julia/milestone/4

That's actually a bit out of date. The nightly builds are now 0.7 (not sure I've seen this mentioned beyond Discourse/Github). It will primarily serve as a depreciation release, i.e. things that would have just broke when going from 0.6 -> 1.0 will instead throw a depreciation warning.

1.0 and 0.7 will come out at the same time. The recommended upgrade path will be to run the application and tests under 0.7 and fix any deprecation warnings, then switch to 1.0 where those warnings will become errors and fix any you missed. Should be pretty straightforward and allows us to release 1.0 without any deprecations.

This feels appropriate:

https://danluu.com/julialang/

tl;dr: Julia is a great idea, but with poor testing and quality control. Community is (apparently) a bunch of dicks.

Just to be clear, I don't personally have much experience with it, I'm just summarizing Dan's review.

"Community is (apparently) a bunch of dicks."

This is not true at all. I personally know some of the core devs, they are very sharp programmers and very humble people. The community is very open to suggestions, and very welcoming to new people.

Yes, just my personal experience, and I'm not claiming that no one ever had a bad experience, but I didn't want to let that pass unchallenged.

I don't recall Danpuu's review including the negative view of the community. Maybe it'll need a re-read. Dan also ended with "I plan on using Julia in the future" conclusion.

Anyhow, the community never seems standoffish or "dickish" to me. I've had good responses, despite disagreeing on a few PR requests.

I would say there is still a bit of a quality control issue but it's still a young project. Hopefully the new funding and commercial support will help pay for better QC. Not many of the core team appear to have done much in the way of "plain old software development" so the community lacks a bit of learning from applying things in industry. Likely the ongoing experience with Julia and the various support contracts will shore that up quickly. :-) For example, there was a (defunct) startup Staffjoy doing schedule optimization using Julia and their write up was that little things like dropping literal Dict syntax was a huge pain for their test code [1].

[1]: https://blog.staffjoy.com/retro-on-the-julia-programming-lan...

If I recall, the original post had a slightly negative comment about the community itself which was later removed and then even later made clear that the negativity was primarily with one of the co-creators.

> testing and quality control

There have been major improvements in the past three years and code coverage is now consistently above 80%.

> Community is (apparently) a bunch of ...

I'm admittedly biased, but based on a number of years of experience and personal efforts, I think this is not a fair characterization. I don't know what happened in that private forum -- but I do know that the Julia community is thousands of people, with a huge, public archive of helpful, respectful interactions among newbies, non-Julia experts, core devs, and everyone in between.

https://groups.google.com/forum/#!forum/julia-users

(Disclosure: Julia committer)

Just want to point out that the community forums moved from Google groups to Discourse awhile ago.

https://discourse.julialang.org

I invite you to join the community and decide for yourself how the community is. You will be quite surprised that it is one of the nicest communities there is.

"Community is (apparently) a bunch of dicks."

Not everyone (most are kind and welcoming), but yeah that has been my experience as well with some members.

https://danluu.com/julialang/ brings up some good points

Have they been addressed by now?

See the thread above. Short answer: yes.

Reply on news.ycombinator.com