About the v0

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!

v0 is now Stable (essentially)🔗

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.

What is `v1`?🔗

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.

More About the Version Numbering🔗

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.

Clojure Stability🔗

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.

What is the actual Plan?🔗

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.