About

We believe that strong static typed, pure functional programming (FP) has a lot to offer in terms of software reliability and performance. However it has a well-deserved reputation for being difficult to learn for newcomers. FP can also be difficult to use for experienced functional programmers.

Multicore computing is ubiquitous, and other promising parallel architectures either available or on the horizon; we believe that it is necessary that parallel and concurrent programming is available and straight forward.

Goals

Plasma hopes to address these challenges with the following goals.

  1. To combine declarative and imperative programming features.

    We will combine the safety and reasoning power of strongly typed pure FP with a familiar imperative-like syntax. We will support loops, arrays and other imperative programming features. This benefits both experienced developers and novices.

  2. Simplicity

    Keeping things simple is an excellent engineering practice. It also makes the language and tools easier to understand.

    Plasma will have a reduced emphasis and dependence on abstract concepts like monads. They're still supported, but now they can be learnt gradually. Many interfaces will have more sensible names, eg: Mappable rather than Functor. We will also aim for good tooling and a consistent syntax; things that are different will look different.

  3. Excellent parallelism and concurrency support.

    Channels, mvars, semaphores, streams, futures and software transactional memory provide safer abstractions than traditional threads and locks concurrency.

    Deterministic parallelism makes parallelism available without constraining the structure of your program or affecting its declarative semantics, eg: Haskell's par function or strategies.

    Automatic parallelism can optimize your code by applying determinstic parallelism for you during compilation.

For more information and an overview of some features please see the Presentation at Compose :: Melbourne 2016.

Features

Declaratively pure
helping programmers more confidently understand their programs, making debugging easier. Purity also makes it easier to apply many optimisations including automatic parallelisation. Plasma uses a resource system to make effects safe. Resources are composable unlike monads.
A strong, static type system
supporting ADTs, parametric polymorphism, interfaces and type inference.
Eagerly evaluated.
Eager evaluation makes performance and other behaviours more predictable.
Direct support for loops
for map, reduce, filter and combinations. Loops work on different aggregate types. See Loops in the reference manual.
Bytecode and native code
Generic token-based bytecode interpreter, in the future more optimal bytecode interpreters for each major platform. and hopefully native code generation.
Foreign Function Interface (FFI)
Interoperability with C.
Multiple concurrency abstractions
Tasks, channels, mvars, futures and STM.
Manual and automatic parallelisation
Parallelise programs based on data-flow, loops and possibly pipelines either by adding annotations or automatically. See my Ph.D. research.
Free/Libre software
MIT License

Publications

The following things have been published about Plasma.