The current version of YS as of today is 0.2.1
.
I'm sure you've noticed the v0
part of the !YS-v0
tag by now.
YS intends to be a "versioned programming language", where v2
can behave
very differently from v1
while still being able to use v1
libraries and
such.
Today I'll tell you a bit more about the versioning and how things are expected
to work.
Remember, we are still officially at v0
so even the rules of how versioning
works are not yet set in stone!
I'd like to start off by saying that v0
is essentially stable at this point.
This means that YAML files starting with !YS-v0
should continue to work
without any changes.
Put another way... "Don't worry, be YS!"
Work is currently under way to put out a stable v1
release in the next couple
of months and then start work on v2
.
It might seem strange to only spend a couple of months on v1
.
It won't be much different from v0
when it is released.
Actually that's the point.
Declaring the stable version to be v0
doesn't make much sense.
At least it doesn't seem like it would spark much confidence.
Having a stable v1
out there is what many people are waiting for.
In reality it shouldn't be much different than how things stand today.
But it will be a promise.
The promise is that, once released, all code written for v1
will continue to
work in the future.
While v1
is under development, it will be available to use as !YS-v1-a
.
In essence, the v1
(short) dev period will be useful for ironing out the
details of creating a new YS version.
The v0
, v1
, v2
etc indicates the major version number (in the semver
sense) of the YS language version.
The plan is to use semver for the versioning.
v1
shows up in several places:
- The
!YS-v1
tag
- The
#!/usr/bin/env ys-0
shebang line
- The
ys-0
and ys-0.2.1
binary names
Somehow any piece of YS code needs to know what version of YS it was written
for.
When v3
comes out, it should be able to use libraries written for v1
, v2
,
or v3
.
It's an ambitious goal, but it should allow for a lot of flexibility and an ever
improving language.
To pull this off, it is very fortunate that Clojure is extremely stable and
backwards compatible.
In my personal experience, I've never seen Clojure code break when upgrading
to a new major version of the language and/or tooling.
I wrote up a couple of internal documents for the YS team about v1 and
versioning.
I'll share them with you now that the team has had a chance to review them:
These documents are still subject to change, but they are what we are working
with now.
If you have any questions, or suggestions, please let us know.
You can start in the comments below.