.. glossary::
:sorted:
acked
acking
acknowledged
Acknowledgment marks a message as fully processed.
It’s a signal that the program does not want to see the message again.
Faust advances the offset by committing after a message is acknowledged.
codec
A codec encodes/decodes data to some format or encoding.
Examples of codecs include Base64 encoding, JSON serialization,
pickle serialization, text encoding conversion, and more.
consumer
A process that receives messages from a broker, or a process
that is actively reading from a topic/channel.
message
The unit of data published or received from the
message :term:`transport`. A message has a key and a value.
publisher
A process sending messages, or a process publishing data to a topic.
sensor
A sensor records information about events happening in a running
Faust application.
serializer
A serializer is a :term:`codec`, responsible for serializing
keys and values in messages sent over the network.
topic
Consumers subscribe to topics of interest, and producers send messages
to consumers via the topic.
agent
An async function that iterates over a stream.
Since streams are infinite the agent will usually not end unless
the program is shut down.
task
A task is the unit of :term:`concurrency` in an :mod:`asyncio` program.
concurrent
concurrency
A concurrent process can deal with many things at once, but not
necessarily execute them in :term:`parallel`. For example a web
crawler may have to fetch thousands of web pages, and can work on them
concurrently.
This is distinct from :term:`parallelism` in that the process
will switch between fetching web pages, but not actually process
any of them at the same time.
parallel
parallelism
A parallel process can execute many things at the same time,
which will usually require running on multiple CPU cores.
In contrast the term :term:`concurrency` refers to something
that is seemingly parallel, but does not actually execute at the same
time.
thread safe
A function or process that is thread safe means multiple POSIX
threads can execute it in parallel without race conditions or deadlock
situations.
transport
A communication mechanism used to send and receive messages, for
example Kafka.
event
A happening in a system, or in the case of a stream, a single record
having a key/value pair, and a reference to the original message
object.
idempotence
idempotent
idempotency
Idempotence is a mathematical property that describes a function that
can be called multiple times without changing the result.
Practically it means that a function can be repeated many times without
unintended effects, but not necessarily side-effect free in the pure
sense (compare to :term:`nullipotent`).
Further reading: https://en.wikipedia.org/wiki/Idempotent
nullipotent
nullipotence
nullipotency
describes a function that'll have the same effect, and give the same
result, even if called zero or multiple times (side-effect free).
A stronger version of :term:`idempotent`.
reentrant
reentrancy
describes a function that can be interrupted in the middle of
execution (e.g., by hardware interrupt or signal), and then safely
called again later. Reentrancy isn't the same as
:term:`idempotence <idempotent>` as the return value doesn't have to
be the same given the same inputs, and a reentrant function may have
side effects as long as it can be interrupted; An idempotent function
is always reentrant, but the reverse may not be true.