422404 / actorlang

A small interpreted language for actor programming.

actorlang's Issues

Add system properties

System properties would be a special kind of variables.
These variables would have qualified names using dots as separators as a convention.
They would allow to alter the system behavior or retrieve info about the system.

Example:

display @system.network.ipv4;
...
@system.events.logger = create Logger ("debug");

Add PoisonPill value

Add a PoisonPill literal value. When an actor retrieve a message with a PoisonPill value from its mailbox, the actor must stop any further messages processing.

Create specialized exceptions in the evaluators

It might help to show appropriate errors in a language extension.

Separate the interpreter from the actor system

Create a vscode language extension

The extension would enable syntax highlighting and running scripts from the editor.

For such an extension, we would need an LSP compliant language server (we could build one with LSP4J).

Features:

• Syntax highlighting
• Code completion
• Run the currently opened script
• Run scripts from the filesystem tree
• Start registries
• List all running scripts/registries in a tree view in a separate activity bar container
• Add an output channel were the logs of the running instances would be outputted

Use the Gradle configuration avoidance API to speed up builds

Integration test "An actor can become another actor type" failed in InterpreterImplIT.kt

See the relevant line in the workflow.

Log errors and warnings

Logs should be outputed to stderr.

Add an option to suppress log messages.

Release notes as a file in the repo

Add a file named NOTES.md that will be read by the "release" action.

The content of the file will be set as the release notes.

Add collections

Add collections and built-in functions to manipulate them.

Example:

myList = newList();
listAdd(myList, 1337);
listRemove(myList, 1337);
if (listContains(myList, 42)) {
  ...
}
if (listEmpty(myList)) {
  ...
}

mySet = newSet();
...

myMap = newMap();
mapPut(myMap, "hello", 42);
mapGet(myMap, "hello");
mapRemove(myMap, "hello");
if (mapContains(myMap, "hello")) {
  ...
};
keys = mapKeys(myMap);
values = mapValues(myMap);

Use ANTLR4 `CharStreams.fromFileName()` instead of reading the input file ourselves

Use a Gradle convention plugin to group common project configuration

Add multi-process capability

Add the ability to run a registry were remote actors would be exported by scripts.

Example:

frontend.actor:

$x The x value
$y The y value
---

ResultPrinter () [result] = {
  display result;
  shutdown
};

printer = create ResultPrinter ();
send [$x, $y, printer] to remote "Compute/Sum"

backend.actor:

fun sum(x, y) = x + y;

SumBackend () [x, y, callback] = {
  send [sum(x, y)] to callback
};

backend = create SumBackend ();

bind backend to "Compute/Sum"

Run:

REGISTRY=127.0.0.1:8080
actorlang registry $REGISTRY &
actorlang run --registry $REGISTRY backend.actor &
actorlang run --registry $REGISTRY frontend.actor -x 20 -y 22
# Prints: 42

Add collection iteration

Add a way to iterate over the items of a collection.

Example:

for (a of newList(1, 2, 3)) {
    display a
}

Upload a merged coverage report to Codecov

Multiple coverage reports are currently sent to Codecov, one for each module that contains tests. This is not optimal as tests in a module should be able to add coverage data to another one. The JaCoCo Report Aggregation Plugin could help with it.

[Security] Workflow quality-gates.yml is using vulnerable action eskatos/gradle-command-action

The workflow quality-gates.yml is referencing action eskatos/gradle-command-action using references v1. However this reference is missing the commit 6ff2065a1233a621be482a67cf97261047133d35 which may contain fix to the some vulnerability.
The vulnerability fix that is missing by actions version could be related to:
(1) CVE fix
(2) upgrade of vulnerable dependency
(3) fix to secret leak and others.
Please consider to update the reference to the action.

Add a shutdown statement

Add a shutdown statement that shuts down the current instance.

Exclude the docs/_build directory from git

ReadTheDocs rebuilds it anyway so it is useless to commit the build output.

Display an error when an actor does not understand a message

Log the position of the send statement that triggered this error.

The send statement position will have to be added to every messages sent by an actor.

Add some code snippets in the README.md

It helps to give an idea of what this repo is about.

Document how to build the docs

Create a Mailbox for each actor

Schedule actors using thread pools

Add some tutorials/examples in the docs

Add a way to implement the reaper pattern

Add a way to implement the Reaper Pattern without introducing complex functionalities to the language.
It could be done by adding these functionalities to the system:

• A shutdown statement which shutdown a running instance
• A PoisonPill literal value which kills an actor receiving it
• Sets
• A way to indicate that an actor must receive messages about other actors death

Example:

Reaper (Actors) [dead] = {
  if (setContains(Actors, dead)) {
    setRemove(Actors, dead)
  }
  if (setEmpty(Actors)) {
    shutdown
  }
};

MyActor () ["display", str] = {
  display str;
  send [PoisonPill] to self
};

MyActor () ["start"] = {
  send ["display", "Hello, world!"] to self
};

actor = create MyActor ();
trackedActors = setNew();
setAdd(trackedActors, actor);
@system.events.reaper = create Reaper (trackedActors);

send ["start"] to actor

Add parameters to scripts

Add a way to pass arguments to a script.
We could introduce something like a parameter block that lists parameters and their usage.
The parameters usage would show up if the user requests the help of the script (e.g. with a --help switch).

Example:

$retryCount The number of time to retry ...
$timeout    The number of seconds before ...
---

Actor (RetryCount) ["hello", timeout] = {
  ...
};

myActor = create Actor ($retryCount);
send ["hello", $timeout] to myActor;

---

These libraries could be investigated:

• Clikt
• Kotlin arg-parser

One thread receives all the messages and posts them into the mailboxes

Create a Logger abstraction and pass it to all services

class MyClass(private val loggerFactory: LoggerFactory) {
    private val logger = loggerFactory.newLogger(this::class)

    fun myMethod() {
        logger.info("Hello from my method!")
    }
}

Rework the bundled examples

Only bundle the ANTLR 4 Runtime with the CLI

Do as this comment says.