OrcScala is the re-implementation of the Orc compiler, runtime, and library using the Scala language.  OrcScala's first release will be Orc 2.0.

!! Changes

We have an ongoing list of to-do items under OrcScalaToDo

The Scala implementation operates over a modified version of the Orc language, as discussed under LanguageDefinitionIssues. 

It also includes term, type, pattern, and {{+}} operator support for ExplicitRecordSyntax.

! Capsules

We reviewed the semantics of capsules and made the following decisions. These are consistent with the behavior of capsules in the Java implementation.
* A capsule execution does not terminate after its first publication. It continues to execute, and its subsequent publications, if any, are ignored.
* A capsule shares its output stream with its parent execution. Currently this happens as a result of the way capsule executions are created; eventually it will simply be a consequence of the two executions sharing the same {{Print}} site.
* A capsule shares its error stream with its parent execution. This is appropriate since error messages will point to source locations within the original program source, in which both the host program and the capsule code are contained.
* A capsule shares its parent execution's scheduler and clock. Thus, conceptually, a capsule is on the "same machine" as its parent execution; it is simply a forked "process"
* A capsule shares its parent execution's invocation semantics, since the semantics are a property of the language, not of the execution environment, and besides there would be no good alternatives as defaults.
* An execution will wait for its dispatched capsules to halt before it halts. In this way, capsule executions are not "abandoned" when their parent execution completes. Furthermore, they are not unexpectedly terminated.

!! Remaining Work

Logical time is not implemented in Orc Scala. Currently, the {{Ltimer}} site is simply a stub which calls {{Rtimer}}, at 100ms per logical time unit. {{withLtimer}} is entirely unavailable. The semantics of logical time is still an area of ongoing research.

The typechecker is not implemented in Orc Scala. There are very few conceptual barriers here, as the typing algorithm is based on existing published work, and will not change much in moving from Java to Scala. It will simply take a lot of time to complete, and it is not a high priority at present, especially given the progress that has been made with using Orc as an EDSL within strongly-typed Haskell.

The system needs extensive documentation. This was already needed for the Java implementation, and is even more important for Scala, since some of the underlying execution strategies have changed.

There are still a few loose ends, such as def group partitioning, correct strictness for closures, and additional functionality for records.

!! Building

# Download Eclipse Classic 3.6.1
# Modify {{eclipse/Eclipse.app/Contents/~MacOS/eclipse.ini}} per the [Scala IDE instructions|https://www.assembla.com/wiki/show/scala-ide/Setup]
# Launch Eclipse
# Install Subversive from the Helios update site in Eclipse
# Install the SVNKit 1.3.2 connector (should be prompted automatically)
# Install the Scala IDE from download.scala-ide.org—nightly-update-helios-2.8.0.final
# Check out the following projects from the SVN repository: {{OrcScala}}, {{~OrcExamples}}, {{OrcSites}}, {{Orchard}}, {{OrcEclipse}}, {{~OrcDocs}}, {{Website}}