0.6 syntax changes


#1

0.6.0 breaks syntax stability, so many, MANY packages doesnt compatible with the latest Julia at all.
Its a pitty, because package maintainers may be dismotivated to update its code: next Julia versions may break compatibility with 0.6.0, and so on.
Why Julia syntax is SO unstable? Look at Crystal - this is experimental language in pre-beta stage, but its syntax is very stable…


Julia 0.6.0 released
#2

0.6 brought many new features. My perception is that they were eagerly awaited by users (including package developers), instead of treated as a nuisance (look at the topics asking about release dates — it’s like kids on Christmas Eve who don’t want to go to sleep in case they miss Santa).

The community expanded a lot of effort to make the transition smooth, but this is not always possible. The expectation is that packages will catch up soon (some already have). If you notice that they have not, you can open an issue (for the relevant package), or even better, submit a pull request.

That said, in addition to being a practical language, Julia is also an experiment in designing a language with certain features. This involves exploration, experimentation, backtracking, and breakage. Occasional inconvenience is the price to pay for a great language.


#3

No, breaking changes will become much fewer very soon. The point was to get as many breaking changes in as soon as possible, and before version 1.0, which is coming in some months.

Once 1.0 is here, breaking changes will be rare.


#4

Describing Julia’s syntax as “SO unstable” is simply inaccurate – Julia’s syntax has be remarkably stable since the 0.1 release. The 0.6 release is the first one with major syntax breakage without smooth deprecation, so if this is your first Julia release transition, then this is not a typical experience – generalizing from it may have led you to the wrong conclusion about Julia’s syntax stability. In previous releases there were a few minor literal syntax changes (dicts, tuple types), but they had smooth deprecations, and otherwise syntax that worked on 0.1 still works today. The changes in 0.6 were not undertaken lightly: we had long debates about if the changes were worth it, and they were deemed to be. The new type keywords – I assume that’s what you’re talking about – are much clearer, more semantically intuitive, have better defaults (immutability by default, rather than mutability), and are more extensible so we can add more syntax in the future without breaking things. Packages can support 0.6 and earlier versions at the same time with Compat.jl by using the older keywords, which were not deprecated for this exact reason. Once 1.0 comes out, it will no longer be possible to support 1.0 and earlier versions, but when that happens, we will be strongly encouraging users and package maintainers to drop support for all pre-1.0 versions of Julia.

I’m no expert on what Crystal has been doing in terms of syntax – perhaps it is super stable, but a little googling seems to indicate that there have been some non-trivial breaking changes not long ago [1, 2]. Overall, Crystal largely cleaves to Ruby’s syntax, so it’s possible that they don’t need to make as many syntax decisions in general as we do – Julia is largely in new language design territory as one of the only multiple dispatch-based languages around (Dylan being the other mainstream one, which is essentially completely unrelated syntactically).


#5

For what it’s worth, I’ve been involved in updating a number of packages for 0.6 and, in my experience, updating for 0.6 is very easy. It’s updating for 0.6 and maintaining compatibility with 0.5 that’s hard. I sort of wish people would be more willing to break compatibility with previous versions until 1.0 is out.

I’d much rather put up with some minor breaking changes now and wind up with a language that does things right. The world is already replete with languages that made too many compromises.


#6

Dare I ask what breaking changes you’d like to see?


#7

Sorry, that was poorly phrased. What I meant was, “I’d much rather put up with the changes that the Julia devs have been making and wind up with a language that does things right.”. I should not have implied that these are “breaking” changes. I’m pretty happy with the current state of affairs.