Phase One

What this phase aims for

• Reversible event handling, and how it meets synchronous work

  Events can be handled in a way that can be unwound, and the rules for how that reversible handling intersects with ordinary synchronous operations are settled.

• Effect handling

  How effects are described, raised and handled is defined, so that side effects are explicit rather than hidden inside the code that triggers them.

• Sandboxing and drivers

  How a program is sandboxed, and how drivers sit at the boundary to give it controlled access to the outside world, is worked out.

• A basic serialised syntax tree

  A first version of the serialised syntax tree format — how a program is stored on disk and passed between tools — is in place.

• Rendering into a first set of languages

  A method for rendering a program into an initial set of target languages exists, so the same tree can be turned into running code.

Decisions & compromises

There are a lot of features to pack into a small space, so not every problem is solved cleanly and a few rough edges remain. These are the ones worth calling out:

• Data objects cannot mix readable and writeable fields

  A data object is readable and writeable as a whole variable, not field by field. There is no way to describe a structure where some fields are read only and others can be written — the distinction applies to the whole thing, so you cannot combine both in a single object.

• Value IDs are exposed in the language itself

  Because a structure cannot mix read-only and writeable fields, the underlying IDs of values end up surfacing in the language at various points. To work around this the language has to support explicitly pulling those references out into plain integers inside the program. This is mainly used for communicating with the drivers.

What is not solved yet

Several things are still open and are left to later phases, so the format is not fixed before it is ready:

• Context availability is not checked

  Available and required context are not automatically checked. The code is still clear in most places, but it is possible to trip up by trying to use a context that is not available — the system does not stop you ahead of time, and you only find out through a runtime error.

• Context is not a built-in feature

  Sharing values at a distance is still handled in the library rather than baked into the language itself. Building it in is the work of Phase Two.

• The language is not self-hosted

  The toolchain is not yet written in Program itself. That waits until the format is pinned down.

Next

Phase Two → builds context into the language and makes mode-based programming possible.