version numbering confusion

Server:

The version number consists of values for major, minor, build, and svn-revision and an optional extension for how stable and complete it is supposed to be (Prealpha, Alpha, Beta, Release Candidate (RC) or in case, that its final, no extension at all).
So for RC9 this means:
major version: 3
minor version: 0
build: 24 (counting only builds, that have ben released as 3.0, but counting not builds of other versions and not counting internal builds)
svn-revision: 3243
optional extension: RC9 (9th release candidate of Photon 3.0)

So, yes, the 3.0 RC9 is still prior to the imminent 3.0 final, which will definitely have higher values for build and svn-revision.

You are right that it can be confusing, when some values other then the major-version are already !0 before the final 3.0, but for a build# and a svn-revision there is not really any other option than already counting them up for Betas, RCs, etc.



Client:
Here we have major-serverminor-clientminor-fix-optionalExtension.
So something like 3.0.3.4 means, that that client is a Photon 3 client, that is compatible to the client-server interface of all Photon 3.0 server-releases (but not guarenteed to be compatible to 3.1 and up servers, as well as 3.1 clients are not guarenteed to be compatible to 3.0 or 3.2 servers, etc.) and accordingly to all other 3.0 clients independently of their platform and that it is the 3rd API-change release of a Photon 3.0 client for that client platform and the 4th bugfix release for that 3.0.3 release. As there is no extension behind the number, this client is considered to be final.

Although on the client side there is no build or revision in the version, it is still possible to have something like 3.5.9.12-PreAlpha, which would indicate, that for that certain platform for which the client is, the port to that client is still considered to be in an early state of development, although it shares platform independent code with other client platforms for the same programming language, that are considered stable for long times, as the high 2nd, 3rd and 4th value in the version show.

As an example we have added AndroidNDK as C++ client platform after our Photon 3 C++ clients have become final and as they share all platform-independent parts of their code with our other C++ clients, they also share thei version-number, which already has been past 3.0.1.0 at that time, so there actually has been a 3.0.1.0.PreAlpha and then later a 3.0.3.0.Beta release of our AndroidNDK clients.

Accordingly the first two numbers are consistent among all client platforms for reasons of being able to recongnize compatibility on the version even interplatform.
However the 3rd and 4th version depend on the code-base, from which the clients get build:
All C# clients share one version, no matter the platform.
The same is true for all Java clients (although currently there is just 1 supported platform).
Same for Action Script.
And also for Javascript.
For C, C++ and objective C the situation is a bit different: When it comes to versioning, then these 3 programming languages are just 1 language, named "native" for us, as they all use the same code-base internally and only differ in their API-language.
So if you see a 3.0.1.15 client for one and a 3.0.4.2 client for another platform, then this does not nessecarily mean, that the latter one has been released after the first one, but just, that its client-API has changed more often since 3.0.0.x, but both clients will be compatible to each other, as they are both 3.0 ones.



PS:
Although RC9 officially is still a RC, it is fine to use it in production-code. The features, that it has, are stable, it just still does not have all features, that will be in the final 3.0.


PPS:
Having a version past x.0.0, thats not called final, isn't a quirk of Photons versioning, but pretty common.
For example Apple has released an iOS 5.1.Beta3 right before the final iOS 5.1.