Reference / glossary

Every word, in one place.

New tools come with new words, and nothing is more annoying than docs that use a word they never explained. So here are all of ours, each in a sentence or two. You don’t need to learn these first. Every page that uses one explains it at the top, and this page is here for when you want to look one up.

process: One small worker inside your program. It keeps its own private data, reads one message at a time from its own inbox, and can be restarted without disturbing anything else. Some people call it an actor.
message: A piece of data sent to a process. It waits in the process’s inbox until the process gets to it.
mailbox: A process’s inbox: the line of messages waiting for it.
state: The data one process keeps. Only that process can read or change it.
behaviour: The function that handles a process’s messages. It takes the state and one message, and returns the new state.
imgo: The cut-down version of Go that processes are written in. An imgo file is a Go file with //go:build goer as its first line; Goer compiles it and the normal Go compiler skips it.
the goer command: The command-line tool. It wraps the ordinary go command and also compiles your imgo files.
supervisor: The part of Goer that watches processes. When one crashes, the supervisor is told and decides whether to start a fresh one.
restart rule: What a supervisor should do when a process stops: bring it back after a crash, always bring it back, or leave it stopped. Also called a restart policy.
Pid: A process’s address. You send a message to a Pid.
port: Ordinary Go code that a process can message to reach the outside world: files, networks, clocks, other services. A process can’t touch those directly.
Ask: Send a request and wait for the reply. Only the process that asked waits; everything else keeps running.
task: A slow job that Goer runs off to the side for a process, and that reports back as a message when it finishes.
native actor: A process written in regular Go. It gets the same mailbox and supervisor as any other process, and holds ordinary Go data.
template: A recipe for a process, registered under a name so it can be started later, including from another machine.
node: One running Goer program. Each node has a name.
cluster: Several nodes connected to each other, so their processes can send each other messages.
link: A tie between two processes: if either one crashes, the other is stopped too.
monitor: A way to watch another process. You get one message when it stops, and nothing else changes.
dashboard: Goer’s built-in web page for watching a running system: which processes are alive, what’s waiting in their mailboxes, what crashed.
snapshot: A summary of a running system at one moment: counts, names, and timings, never your data.
tracing: Recording an event each time a process handles or sends a message. Off unless you turn it on.
safe point: The gap between two messages, when a process has finished one and not started the next. It’s the only moment Goer changes a process’s code.
hot swap: Changing a running process’s code without stopping it.
migration: A function that converts a process’s data from an old shape to a new one, used when new code needs different data.
interpreter: The part of Goer that runs imgo code one step at a time. It works everywhere.
JIT compiler: The part of Goer that turns imgo code that runs a lot into machine code, so it runs faster. JIT stands for just-in-time. It’s available on some platforms; elsewhere the interpreter does the job.
VM: Short for virtual machine: the interpreter and compiler together, the thing that actually runs imgo code.
scheduler: The part of Goer that decides which process runs next. A few workers take turns running whichever processes have messages waiting.
reduction budget: How much work a process may do before it has to let others have a turn.
arena: The block of memory that belongs to one process. When the process ends, the whole block is handed back at once.
garbage collector: The part of Go that finds memory nobody is using any more and frees it. While it works, the program can pause briefly. Often shortened to GC.
slim process: A stripped-down kind of process that only understands a few fixed messages. It exists for huge crowds; the benchmark uses it. Also called a compact actor.
megapark: The program in the Goer repository that we use to measure very large numbers of processes.
msg.Spec: How regular Go code writes a message: a type name and a list of fields.
GoerModule: The compiled imgo code for a package. The goer command generates it for you.
WebAssembly: A portable program format that runs in browsers and other sandboxes. Often shortened to wasm.
heartbeat: A small signal two connected nodes keep sending each other. When it stops, each knows the other is gone.
CRDT: Short for conflict-free replicated data type: data that several machines can each change on their own and that still merges to the same answer everywhere.
replica: One machine’s copy of some shared data.
tombstone: A marker left behind when something is deleted from shared data, so an old copy elsewhere can’t bring it back.

Getting startedSee these words in action →ArchitectureHow the pieces fit together →ReferenceThe exact spelling of everything →