Next Julia LTS: 1.5 or make it 2.0?

I seem to remember talk of Julia 1.5 likely to be made the next long-term-support (LTS) version (at least 1.4 isn’t that version).

Julia 1.5 has a due date for April 15, 2020, and seems likely on time (with 8 open issues) and seems will be a very fine release.

There’s no due date set for 2.0 milestone, but it has some trivial (and other non-trivial) issues such as:

Could 1.5 be skipped and made that next 2.0 and all such trivial 2.0 stuff be included?

Why release 1.5 now as 2.0? I can think of several reasons:

  • While the soft scope capability (what we had prior to Julia 1.0, and back in 1.5) is deemed technically non-breaking, as it only affects the REPL, but to users it will feel like a (welcome) change.
  • The operators " ± and ", now also unary, if I recall, had some precedence issues, and we could fix those? It’s not like those are much used yet? So fix the precedence as early as possible.
  • Often major releases work as a publicity boost. As I think 1.5 is solid, and thus also 2.0, at least if we only a few “technically breaking changes”, I think 2.0 now will be better than later.

The downside of a major release can be: people view it as incompatible. I’m thinking if we could add only stuff that all can agree on and can be done quickly, with minimal breakage, then that will not be a problem.

One 2.0 issue waiting is “and”, “or” (and “xor”?) operators. I think we can just define them to do nothing (i.e. be read with a parse error), for now (something we could always take back), then only very odd code would brake, code that used those as variable names. That way we can define them later in a point release to to what we want. It’s not for sure they would only be synonyms for && and ||, but we should wait with that discussion.

We can’t really take back releasing 2.0, but we can hold off declaring it as LTS.

[EDIT: That was just speculation for later, if the above turns out to be a mistake.]We could however decide to release 1.5 (what’s currently meant for that release) AFTER 2.0, if we feel this is a mistake.

We can always release 3.0 later for most of the stuff already on the 2.0 milestone. It’s not like 2.0 seems really on the radar.

What more issues should be added to 2.0? E.g. “Deprecate norm(x,0)” issue? Issues only affecting macros like “Parse 1 + 2 + 3 as +(1, +(2, 3))”? I recall a similar think for multiply (not a listed issue I think), where for matrices multiplying from right to left could be faster, but that might be to big of a change? I’m not sure it that could be a controversial change, or “technically breaking”?

Definitely not. There is a long time until an eventual 2.0.

That doesn’t make any sense to me. What would happen to the 2.0 release? Which one would people use?


Yes, it’s not on the radar now, I’m however proposing it. You didn’t comment on making 1.5 LTS. If we do that, then we’re stuck with stuck with that for a long time (by definition), and we wouldn’t want to release 2.0 any time soon? What do you really have against an early 2.0?

About releasing 1.5 later, after 2.0, was just an idea (a plan B), just like we release 1.4.1 or other backport releases all the time. Only if someone insisted on 1.5 without those braking changes. Similar to the 0.7 release. I wouldn’t oppose releasing 1.5/2.0 together as was done with 0.7/1.0 but am just not sure it’s needed. Nor exited about waiting for 2.0 with only those few breaking changes, or waiting a long time for 2.0 with more.

Yes, we would be “stuck” with 1.5 as a LTS for a long time until the next LTS release. What’s the problem again?

Yeah, that’s correct, we wouldn’t. An early 2.0 would really erode the trust in that Julia is a stable language that doesn’t willy-nilly break stuff.


I’m not proposing breaking “willy-nilly”. I do like the syntax guarantee. Julia 1 LTS was proposed for 1 year if I recall, and it’s been it’s been more than one and a half. So there are two separate issues, the next LTS, and when 2.0.

We could do Julia 1.5 LTS (or even 1.4 LTS). I just don’t like two or more LTS at the same time, why I’m proposing 2.0, also so it (or later version) can be the next LTS.

We could even do 2.0 with no breaking changes, for just publicity reasons, signaling it’s a good release, or with major new features. Semver doesn’t disallow that. I would also be ok with that, just thinking what more could be added, not controversial stuff:

@Karpinski on Text (and HTML) export (and we’re talking about two? public packages using that export): “It might be possible to remove these exports before 2.0 but only if no one in any package is using them.”

@stevengj response: “If you take semver seriously, then this is simply not an option until Julia 2.0.” at:

Where was that said? I don’t recall that.

That’s just a really bad idea. It probably would give some publicity, it would just be negative though.

Anyway, there isn’t much point discussing this further, I just didn’t want people to get the wrong idea. 1.5 will not be skipped and 2.0 is far away.


Naming something as LTS does not really preclude releasing new stuff afterward. It is just a commitment to fix issues that pop up with the LTS release. The only reason it would get in the way was if maintaining the LTS took up a large chunk of the development time, taking time away from creating new stuff.

On LTS I found no guarantee for how long Julia 1 LTS will be maintained, only:

Others don’t want to upgrade Julia more than every year or so, if that often. […] A long term support (LTS) branch (currently release-1.0 ): an older release branch that will continue to get applicable bug fixes for as long as it continues to be the LTS branch. Extra effort is made to backport bug fixes to this branch

and I see:

Since we only just got 1.0 out, it’s a bit early to start thinking about what 2.0 means. Ideally, we’d like to allow people to opt into breaking changes in minor releases with something like Python’s from future import feature. But the details of such a capability are yet to be determined.