Zum Inhalt springen
Deutsch

Fundamentals — Überblick

Der Bereich Fundamentals deckt alles ab, was du brauchst, um Single-Node-Actor-Systeme zu schreiben. Alle zwanzig-und-ein-paar Seiten existieren, weil sie auf einem mentalen Bild aufbauen: Ein Actor ist ein Ding mit Zustand und Verhalten, das Nachrichten eine nach der anderen verarbeitet. Verschiedene Seiten zoomen auf verschiedene Teile dieses Bildes.

Diese Seite ist die Landkarte.

tell()

ActorSystem

/user (guardian)

Actor "worker-1"

mailbox

onReceive(message)

state · log · children · context.*

child-a · child-b

dispatcher · scheduler · eventStream

callers

Jede Box entspricht ein oder zwei Seiten:

Das ist die ganze Liste. Etwa zwanzig Seiten, jede ~250-400 Zeilen, jede mit Fokus auf einem Ausschnitt.

Drei sinnvolle Pfade:

Schnellster Weg zu “Ich kann einen Actor schreiben”

Abschnitt betitelt „Schnellster Weg zu “Ich kann einen Actor schreiben”“

Für Entwickler, die sofort mit dem Coden loslegen wollen:

  1. Actor — die Klasse.
  2. Nachrichten — die Discriminated-Union-Konvention.
  3. Pattern Matching — das match().exhaustive()-Idiom.
  4. Actor-System — wie du den Actor spawnst.
  5. Ask-Pattern — wie du Antworten liest.

Das sind etwa eine Stunde Lesezeit, danach kannst du eine funktionierende Spielzeug-App schreiben.

Für Entwickler, die das konzeptionelle Bild wollen, bevor sie Code schreiben:

  1. Actor-System — der Container.
  2. Actor — die Entität.
  3. Mailboxes + Dispatcher — was die Eine-nach-der-anderen-Verarbeitung möglich macht.
  4. Supervision + Death Watch — die “let it crash”-Philosophie.
  5. Coordinated Shutdown — wie Systeme sauber enden.

Danach ist der Rest nur noch Detailarbeit.

Für Entwickler, die von einem anderen Runtime-Modell migrieren (Promise/await-Suppe, Worker Threads, BullMQ-artige Queues):

  1. Warum Actors — die Begründung.
  2. Nachrichten — Methoden ersetzen.
  3. Actor — Klassen mit geteiltem Zustand ersetzen.
  4. Supervision — try/catch durch let-it-crash ersetzen.
  5. Ask-Pattern — await-Aufrufer mit actor-internen Abläufen verbinden.

Und dann weiter zu den Migrations-Guides für den konkreten Framework-Vergleich.

Jede Fundamentals-Seite ist gleich aufgebaut:

  1. Was es ist — ein Satz, in der Description im Seitentitel.
  2. Ein minimales Beispiel — lauffähiger Code, ~15-30 Zeilen, inklusive Imports.
  3. Wie es funktioniert — die technischen Details, in Prosa.
  4. Wann (nicht) anwenden — konkrete Situationen + Alternativen.
  5. Häufige Fallstricke — Asides, die die häufigsten Fehler markieren.
  6. Wie es weitergeht — 3-5 interne Links.

Es geht nicht darum, jede Seite auswendig zu lernen; es geht darum, die Form zu kennen, damit du zu dem Abschnitt skimmen kannst, den du brauchst. Die “Häufige Fallstricke”-Sammlung über alle Seiten hinweg ist die mit Abstand beste Ressource, wenn du debuggst.

Sobald dir diese Seiten vertraut sind, baut der Rest der Website darauf auf:

  • Typed — eine strengere, standardmäßig typisierte API für dasselbe Modell.
  • Routing — Fan-Out über mehrere Actors mit Load-Balancing-Strategien.
  • Patterns — wiederverwendbare Bausteine (Circuit Breaker, Retry-Helfer, Backoff-Supervisor).
  • Cluster — der Schritt von einem Node zu vielen.
  • Persistence — Actor-Zustand, der Restarts überlebt.

Jeder dieser Bereiche hat eine eigene Überblicksseite nach demselben Muster.

Wenn du bis hierher gelesen hast und einfach nur etwas schreiben willst:

  • Quickstart — ein funktionierendes Hello-Actor in 5 Minuten.
  • Actor — die Grundlagenseite für alles weitere.