First release of Javallel, Parython; new release 5.1 of ParaSail and Sparkel

The ParaSail family of languages is growing, with two more additions now available for experimentation.  We have made a new release 5.1 which includes all four members of the family -- ParaSail itself, Sparkel based on the SPARK subset of Ada, Javallel based on Java, and Parython based on Python.  Binaries plus examples for these are all available in a single (large) download:

   http://bit.ly/ps51bin

As before, if you are interested in sources, visit:

   http://sparkel.org

The biggest change in ParaSail was a rewrite of the region-based storage manager (actually, this same storage manager is used for all four languages), to dramatically reduce the contention between cores/processors related to storage management.  The old implementation was slower, and nevertheless still had a number of race conditions.  This one is faster and (knock on wood) free of (at least those ;-) race conditions.

As far as how Javallel relates to Java, here are some of the key differences:

1. Classes require a "classinterface" to declare their visible operations and fields
2. There is no notion of a "this" parameter -- all parameters must be declared
3. There is no notion of "static" -- a method is effectively static if it doesn't have any parameters whose type matches the enclosing class; no variables are static
4. You only say "public" once, in the class, separating the private stuff (before the word "public") from the implementation of the visible methods.
5. Semi-colons are optional at the end of a line
6. Parentheses are optional around the condition of an "if"
7. "for" statements use a different syntax; e.g:
   •  for I in 1..10 [forward | reverse | parallel] { ... }
8. "{" and "}" are mandatory for all control structures
9. You can give a name to the result of a method via:  

• Vector createVec(...) as Result { ... Result = blah; ... } 

and then use that name (Result) inside as a variable whose final value is returned

You have to say "T+" rather than simply "T" if you want to accept actual parameter that are of any subclass of T (aka polymorphic).  "T" by itself only allows actuals of exactly class T.

Object declarations must start with "var,""final," or "ref" corresponding to variable objects, final objects, or ref objects (short-lived renames).

There are no special constructors; any method that returns a value of the enclosing is effectively a constructor;  objects may be created inside a method using a tuple-like syntax "(a => 2, b => 3)" whose type is determined from context

X.Foo(Y) is equivalent to Foo(X, Y)

Top-level methods are permitted, to simplify creating a "main" method

uses "andthen" and "orelse" instead of "&&" and "||"; uses "||" to introduce explicit parallelism.

"synchronized" applies to classes, not to methods or blocks

enumeration literals start with "#"