Roadmap

We will measure our progress towards a stable and mostly feature complete
release using several milestones;
each of which is broken into a number of tasks.

Legend

TODO, Not started

Work in progress

Done

Blocked

Feature idea

Milestones

The first milestone, "Hello World", is simply the implementation of a basic
runtime, bytecode interpreter and compiler that is capable of compiling and
executing a hello world program.
Although there are many rough edges, this milestone is now complete, and the
rough edges have been moved to our TODO list.

Hello World

Bytecode assembly tool

Basic bytecode interpreter

Bytecode loading

Token threaded bytecode execution

Bytecode hello world

Basic suite of instructions

Blocks and control flow

Bytecode fibs

Basic compiler that can handle "Hello, World!"

The goal of the second and third milestones, are to be able to
demonstrate the kind of language that Plasma will eventually become,
and allow developers to "get a feel" for the language.
The second milestone, "Language Groundwork", covers the kinds of features that
form the basics of the language, and any groundwork that's required for more
advanced features or may constrain later features.
The third milestone, "Nebula", is where the excitement begins
it will introduce parallelism and concurrency and features that are unique
to Plasma.

Language Groundwork

Language syntax

Basic statements and expressions

Case statments

If-then-else

Basic pattern matching

Type system

Basic builtin types

Sum types

Product types

Generics

Higher order values

Interfaces

Basic resource system

Basic module system

Basic functional features

Higher order calls

Lambda expressions & closures

Partial application

Prelude or basic libraries

More examples

Runtime system

Multi-module bytecode loading

Basic Garbage Collection

Concurrency and Parallelism (Nebula)

Concurrency and Parallelism

Lightweight threads

Basic concurrent communications (channels, mvars etc)

Language syntax

Syntax for lists, dicts etc

Loops

Scopes

State variable notation

Multi-valued expressions

Expression versions of if-then-else and match (w/ multi-values)

Module expressions & module import within code

Runtime system improvements

Operations for different data-widths

Subroutine threaded bytecode execution (amd64)

N:M multi-threading

The remaining milestones represent steps towards a stable release.
While we're revising all the milestones as we go, milestones 4 and onwards
are the most-likely milestones to change.