Java2K - The History

Changes from 0.0.1900 (chair) to 7.3 PRE-GAMMA

Rewrote interpreter from scratch in Python
DIE.py can now set the chance of an instruction to succeed, at runtime.
Fixed some bugs, introduced others. Don't forget, this is my game, I make up the rules.

Changes from 0.0.41 to 0.0.1900 (chair)

Added OPP support.
Added the word "chair" in brackets to the version number: I consider this a very odd joke from the previous stable version...

Changes from 0.0.1 to 0.0.41

Changed the last part of the version number from one-digit to two-digit format. The first digit is 4, the second the current language sub-version [stable].

Changes from 0.0.1 Release Candidate to 0.0.1 [Final Version]

Java2K is no longer multithreaded. Who needs threads, anyway ?
Java2K now has its very own whitespace, -, plus all characters between A-Z, minus the lesser used E and S, which are reserved for future use as thread IDs. Whitespaces can be *everywhere* (in stark contrast to restrictive languages such as plain-java and INTERCAL).
Java2K has no longer any comments. Use whitespaces instead.
The whole concept of functions & variables has been extensively rethought, without any proper result.
Previously, "1 00" was specified as the instruction "Execute argument[0], then argument[1], returns * always.". Starting with 0.0.1 Final, this instruction terminates the running program.
There is now an alternate function call syntax. This makes code much more readable and decreases eye-strain.

Changes from 0.0.1 Beta to 0.0.1 Release Candidate.

Note:Looking back from 0.0.41 to that old version released about one week ago, I must say that I was a bit confused back then. I still am, but that is beside the point: I was confused as to the fundamental language design. It is not easy to top normal Java, and now that Java2 is out, I was under immense pressure to come up with some buzzwords (multi-threaded, instruction pointer, INTERCAL preprocessor) and stuff.

So, I suggest you read this as a blast from the past:

Java2K is now multi-threaded. More so, each program must have 7 distinct threads, no more, no less. There is no means of inter-thread synchronisation other than direct manipulation of some threads instruction pointer, because Java2K no longer has any variables. However, manipulating another threads IP is not as easy as it may sound to you, because in general you don't know your own ID and, because the IP is accessed via thread-id, chances are you will stop your own thread [or, the instruction won't work, see probabilistic programming].
Added DIE - The Java2K IDE. Note that DIE still uses language spec 0.0.1 Beta, so you cannot use threads yet. Editors Note:Even more so, since threads were dumped in Release 0.0.1 Final (although they are scheduled to reappear when J2K development reaches a version number that is a prime divisible by 7).
I have been thinking of making plain INTERCAL the standard preprocessor for Java2K. It should be.
In good tradition, this version is incompatible with earlier versions. There are no longer any variables allowed. You must define functions instead.
Function are now declared the first time they come up in the sourcecode, and cannot be used afterwards. Who needs functions, anyway ? If you came looking for functions as a replacement for variables, well, I am very sorry to disappoint you, you know.
Well, thats not exactly true, the instruction pointer is the only variable this program has. However you cannot only set this pointer to a particular instruction, you can set it to a position in the original sourcecode, provided it can be divided by 7. [IF the instruction works]. Confusing ? It is meant to...
Added Comments - sort of.
Java2K has a new loop instruction: loop forever. This function will not loop forever in the technical sense, because of probabilistic programming.