Speed of evolution of Julia and backwards compatibility

My context and observations:
I’m new to julia (with a goal towards using julia to push data processing to the edge of distributed networks and close to sensors) and as such, first look to language tutorials, and to telemetry protocols such as MQTT. What I found is that julia is evolving so fast that tutorials written as recent as 2 years ago are out of date in regards to syntax, and software packages are also out of date not just in regards to syntax and also semantics, and also packages dependence on libraries that have changed APIs (for example MQTT depends on Sockets, and the Sockets API has changed from when the MQTT package was written 3 years back, the alternate MQTT package from 6 years ago has dependencies on basic/core packages that have changed).
My question: Is there a planned end-date at which julia will be evolved to the point that changes will:

  1. be much less frequent or if that is not possible
  2. have backwards compatibility so that software doesn’t have to be thrown away
    with each new release (you can’t build reliable code on evolving syntax and semantics)
    And if there is an end date planned where this is supposed to happen, I’d like to know what that date is, so I can plan to start coding for real rather than just coding to explore possibilities.

Julia, the language, has backward compatibility since version 1.0 (from 2018), and there are no plans to release a breaking version (which would be a 2.0 release). There can be new features in the language, but old code depending on Julia base will not stop working.

The incompatibilities that you are observing are (almost always, unless packages use some internal Julia function) at the level of packages. And that specifically cannot be managed by anyone but the package developers themselves. Packages normally will get more stable with time, but that is very package specific.

That said, software does not need to be thrown away. Julia provides tools (environments and Manifest files) to allow some code to be exactly reproducible forever, given the same Julia version and the same packages.


Welcome to the Julia Discourse :wave:

Concerning backwards compatibility, Julia itself is stable since Julia 1.0 (August 2018, see Announcing the release of Julia 1.0), that is, when you have a program that you wrote in – say Julia 1.3 and you now open that again in the most recent Julia 1.9.1, it will still run. All changes since Julia 1.0 were (besides internal functions) non-breaking and (just) increasing functionality.

The same holds for packages if you consider their version numbers, they follow https://semver.org.

So as long as you do not update packages beyond a breaking change, your code and also the old examples, still run. For best of cases use local environments for that.


Previous comments where true, but in practice one rely a lot on packages ecosystem.
I would say that as rule of thumb Julia itself became “stable” from 2018, but the most used packages, including the ones with the most dependencies (I suppose those that you call “basic/core”), become stable only around 2020-2021.
I feel the basic ecosystem of Julia is quite stable now.

The previous answers are all that can be reasonably said in response to your pretty broad question. I think it might be more practical to focus on your specific needs than try to work out what “Julia” is doing in the abstract.

I don’t know anything about MQTT but from another thread on this forum I see a link to this package which had some commits two weeks ago so seems to be maintained:


thank you, I’m still figuring things out, this was just my initial impression.