Glossary
The words the rest of the docs use without stopping to explain them. Each entry gives a short definition, a small example when one helps, and the page that explains it in full.
The model#
component#
A component is a definition: a kind of thing, written once. It has ports,
variables, functions and at most one state machine.
Example: component Lamp { var level: uint8 = 0 }.
See Concepts.
part#
A part is one use of a component, placed inside a system or another
component. Two parts of the same component are two separate things.
Example: part desk: Lamp.
See Concepts.
instance#
An instance is one copy of a definition, with its own state and its own variables. In arche-lang, a part is an instance of a component. See Concepts.
system#
A system holds parts and the links between them. It is what Arche draws on
its canvas and what the simulator runs. A system is also a definition, so a
part can be a whole system.
Example: system Room { part desk: Lamp }.
See Concepts.
port#
A port is where a part sends or receives data. It has a direction (in, out
or both), a medium such as CAN or Ethernet, and the messages it carries.
Example: out click: can sends PRESS.
See Concepts.
message#
A message is the data that travels from one port to another. It has named
fields, or is a single value.
Example: message PRESS { count: uint8 }.
See Concepts.
link#
A link joins a port of one part to a port of another. It is written in the
system. archec checks that what one end sends, the other end receives.
Example: button.click -> lamp.cmd.
See Concepts.
state machine#
A state machine lists the states a component can be in and the moves between
them. It starts in its first state. A move happens when its trigger arrives,
such as a message on a port, and its condition holds.
Example: Off -> On on PRESS.
See Concepts.
platform#
The platform is a second system that describes the hardware: the processors and the buses between them. A deployment places the parts of the first system on it. See Concepts.
deployment#
A deployment says where each part runs: which program, on which processor,
in which thread. It changes neither the system nor the platform, so one
system can have several deployments.
Example: binary lamp_fw "lamp.elf" on mcu { thread ctl { runs lamp } }.
See Deployment.
kind#
The word kind has three uses. In a component, it says what sort of element
it is, such as a processor, a device, a bus or a sensor. In a library, it says
what the package holds, such as a driver, a template or a plugin. With
archec new --kind, it says what sort of project to start, such as firmware
or a web service.
Example: kind processor.
See Starting a project and the Arche Store.
Behaviour and code#
handler#
A handler is the code that runs a piece of behaviour: a function's body, what
a port does when a message arrives, or what a state does when it is entered.
The project says which language handlers are written in: TypeScript (the
default for new projects), Python, or the action language.
Example: project "Room" { handlers typescript }.
See Handlers.
action language#
The action language is arche-lang's own small language for behaviour. It is
written in a code block marked arche. archec checks it and translates it: to
TypeScript or Python for the simulator, and to C, Rust or Go for firmware.
See the specification.
target#
A target is one kind of output that archec gen can write, such as C, Rust
for Embassy, Go, ROS 2 or a CAN database file. archec gen --list lists them
all.
Example: archec gen main.arche --target c.
See Code generation.
generator#
A generator writes the files of one target from the model. archec has built-in generators, and you can add your own, written as templates, a script or a command. See Generators of your own.
plugin#
A plugin is one folder that brings generators, importers and exporters to archec together. It can live in your project, come from the Arche Store, or be built into archec. See Plugins.
binding#
A binding connects an element of a screen to something in the model, such as
a variable or the last message a port received. When the model changes,
archec reports the bindings that no longer match. Animations are bound to the
model in the same way.
Example: value bus.STATUS.speed.
See The product's user interface.
Requirements and tests#
requirement#
A requirement says what the system must do. archec reports a requirement that
nothing satisfies or that nothing verifies.
Example: requirement REQ-ON { text "The lamp shall turn on within 50 ms of a press." }.
See Concepts.
satisfies#
satisfies says that a component or a part is where a requirement is met. It
is written inside the component or part.
Example: satisfies REQ-ON.
See Concepts.
verifies#
verifies says that a test case, a test plan or a scenario checks a
requirement. It is written inside the case. (verified-by, written in the
requirement, is the old form: read until 0.13.)
Example: verifies REQ-ON.
See Concepts.
test plan#
A test plan holds test cases. Each case is a timeline: at given times it acts
on the model, then it checks the result. archec test runs the cases in the
simulator.
Example: test-plan TP-ON { case TC-ON-01 { … } }.
See Concepts.
trace#
A trace is a named relation between two elements, such as satisfies,
verifies, derives or refines. archec uses traces to show which part meets
each requirement and which test checks it. Most are written as a property
where they start (satisfies REQ-ON); a trace line is for the other kinds.
Example: trace refines REQ-ON-2 -> REQ-ON.
See the specification.
Projects and sharing#
edition#
The edition is the version of the language a project is written in, like the
Go version in a go.mod file. From edition 0.12 on, old spellings of
keywords are errors. archec fmt --edition 0.12 --write updates a project.
Example: edition "0.12".
See the specification.
library#
A library is a folder of .arche files that several projects share. It has a
name and a version. A project says which versions it accepts, and
arche.lock records the ones it uses.
Example: uses kria-parts "^1.4".
See the tutorial.
store package#
A store package is a library published in the Arche Store. archec add checks
it, unpacks it into your project and records its version. A package can hold a
reusable architecture, a driver, a board, a project template, a plugin and
more.
Example: archec add main.arche acme/can-fd@^1.2.
See the Arche Store.