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 "
∓", 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
||, 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”?