Glossary

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.

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.

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.

concurrent

concurrency

A concurrent process can deal with many things at once, but not necessarily execute them in parallel. For example a web crawler may have to fetch thousands of web pages, and can work on them concurrently.

This is distinct from parallelism in that the process will switch between fetching web pages, but not actually process any of them at the same time.

consumer

A process that receives messages from a broker, or a process that is actively reading from a topic/channel.

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 nullipotent).

Further reading: https://en.wikipedia.org/wiki/Idempotent

message

The unit of data published or received from the message transport. A message has a key and a value.

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 idempotent.

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 concurrency refers to something that is seemingly parallel, but does not actually execute at the same time.

publisher

A process sending messages, or a process publishing data to a topic.

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 idempotence 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.

sensor

A sensor records information about events happening in a running Faust application.

serializer

A serializer is a codec, responsible for serializing keys and values in messages sent over the network.

task

A task is the unit of concurrency in an asyncio program.

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.

topic

Consumers subscribe to topics of interest, and producers send messages to consumers via the topic.

transport

A communication mechanism used to send and receive messages, for example Kafka.