Forget your fucking Go and Rust

ParaSail is the true language of the parallel future. It's from Adacore, it's simple and implicitly parallel through and through.

ParaSail stands for Parallel Specification and Implementation Language. As implied by its full name, ParaSail is for both specifying and implementing parallel applications. As such, it includes high-level specification features, including parameterized modules with full separation of interface from implementation, pre- and postconditions for individual operations within a module, invariants that apply across all operations within a module, and constraints that apply to individual instances of a module.

ParaSail provides support for both implicit and explicit parallelism. Every ParaSail expression is defined to have parallel evaluation semantics. That is, given a ParaSail expression like F(X) + G(Y), the language rules ensure that it is safe to evaluate F(X) and G(Y) in parallel. The compiler makes the decision based on complexity or other criteria whether a given computation should be created as a potentially parallel activity. An underlying scheduler then maps these potentially parallel activities to particular processing resources, by default using a work-stealing approach, which provides load balancing across processors while also providing good locality of reference and minimal cache contention.

https://forge.open-do.org/plugins/moinmoin/parasail/

Why should I use it instead of Ada and SPARK?

The compiler makes the decision based on complexity or other criteria whether a given computation should be created as a potentially parallel activity

This can be done in almost every language with a smart compiler.

>>2
No, it can't. Because almost every language is too complex for computations to be parallelized automatically. Simple example: function parameter aliasing. You pass two arguments to a function and the compiler has no way of knowing if one of them refers to the same datastructure (or a field in the same datastructure) as the other. Hence, it can't parallelize that function (if any of those arguments get modified in the process).

The primary approach to ensuring the safe parallelism is by simplification of the language, with the elimination of features that interfere with safe parallelization. In particular, ParaSail:

eliminates global variables -- operations may only access variables passed as parameters;

eliminates parameter aliasing -- two parameters passed to the same operation must not refer to the same object if either parameter is updateable within the operation;

eliminates pointers -- optional and expandable objects and generalized indexing provides an approach that allows safe parallelization;

eliminates run-time exception handling -- strong compile-time checking of preconditions and support for parallel event-handling provides a safer alternative;

eliminates a global garbage-collected heap -- automatic storage management is provided using region-based storage management which provides immediate, automatic reclamation of storage with none of the global contention and disruption associated with a global garbage-collected heap;

eliminates explicit threads, lock/unlock, or signal/wait -- parallel activities are identified automatically by the compiler, and language rules prevent data races between readers and writers of the same object, while explicitly concurrent objects can be used for safe synchronization when concurrent access from multiple readers and writers is required, without any need for explicit lock/unlock or signal/wait.

I don't see why exceptions need to be eliminated.

What would this be used for?

>>1

One word: The forced operating systemness of the functions

for each Elem of Nums concurrent loop
for I in 1 .. N => <0> + I ** 2

WHATA FUCK MAN xD

>>7
It's just like symta!

>>7
Oh, and I though it used implicit parallelism. I am a fool for thinking that it was good.

FORCED PARALLELIZATION OF THE APPS !