O.G.A.S. Русский

Kinds of nodes

What a graph is built of: each kind of node, its inputs, outputs and settings, and also the patterns that are put together from them and the laws by which nodes work together.

Introduction

The document holds the catalogue of the node system: its make-up, the class of each item and where it is described. The catalogue makes no statements of its own: each entry names an item, puts it into a class and points to where it is described. When the catalogue and the description of the working process (The program: graph and runs) disagree, the description is right and the catalogue is corrected.

A catalogue differs from a subject index: an index gives the name of an item and where it is described, while a catalogue gives the make-up of the node system as a whole: what is irreducible, what is a shorthand, what carries work across the border of worlds and what does not belong to the platform.

The check. make ci compares the catalogue with the code: the kinds of nodes in sections 2 and 3 must be exactly those the engine knows, each exactly once, and every link must lead to an existing section of the documentation.

The codes of the entries are kept as in the Russian original — the letters are Russian abbreviations (table 3) — so that a code means one and the same entry in both languages.

1 The arrangement of the catalogue

1.1 Two axes

An item is described by two independent features. The first is its role in the basis:

Table 1 — The axis of meaning

Class Feature
primitive cannot be built of the others, or needs an indivisibility a composite construction would not have
shorthand can be built, but is kept as a separate kind for readability; brings no new meaning
notation carries no meaning, serves the reading of the graph

The second is its reach:

Table 2 — The axis of reach

Class Feature Place
universal knows nothing of the subject area the platform
transferring carries work across the border of worlds, and on the other side the laws of the graph do not act the platform, with its own law of the border
intermediate built of the universal, but repeated in different areas a library of ready subgraphs
specialised has meaning in exactly one area a module

1.2 The fields of an entry

The fields of an entry are the same for all items: code · name · name in code · class · definition in one sentence · where described.

1.3 Codes

Table 3 — Codes

Letters What they number
УП a primitive node
УС a shorthand node
ПГ a transferring element — a border of worlds
ПБ an intermediate — a ready piece for the library
ЗС a law of the medium: not an element but a property of the medium the elements work in
ВГ a boundary: what the graph does not have and will not have

A card for each kind — what it does, the inputs and outputs with their meaning, what the person sets, what matters for drawing: Appendix A.

2 Primitives

The primitive operations are expressed by kinds of nodes (their count — section 8): merge joins two different primitives, and waiting for an outside event has three forms.

2.1 Beginning and action

Table 4 — Beginning and action

Code Name In code Class Definition Where described
УП-01 event event primitive, transferring a packet appears and starts a run; the source is set by source The program: graph and runs, section 5
УП-02 module module primitive, transferring the only kind that calls outside code; the border of the platform The program: graph and runs, 4, 12.4
УП-15 «Send» send primitive, transferring passes data to another program: a message starts its run, a signal wakes its waiting branch; the only kind that goes beyond its own program The program: graph and runs, section 23
УП-16 «Show» show primitive, transferring shows the person what came and passes the packet on unchanged The program: graph and runs, 24.3; File formats, 16.5
УП-19 «Notify» notify primitive, transferring calls the person with a notification over the window and passes the packet on unchanged The program: graph and runs, 24.6

2.2 The fork

One operation with two axes: the subject of the test (the packet or a variable) and the number of outputs (two or many). The condition expresses the operation itself; choice and switch are shorthands.

Table 5 — The fork

Code Name In code Class Definition Where described
УП-03 condition condition primitive a test from a closed set; the outputs true and false, the data of the packet do not change The program: graph and runs, section 8

2.3 Meetings

Table 6 — Meetings

Code Name In code Class Definition Where described
УП-04 merge-AND merge with policy: all primitive waits for a packet at each input and gives an object of them The program: graph and runs, 10.4
УП-05 merge-OR merge with policy: first primitive takes the first delivered; the input rule any does the same The program: graph and runs, 10.3, 10.4

2.4 Frames

Table 7 — Frames

Code Name In code Class Definition Where described
УП-06 frame «Repeat» repeat primitive a round: the body returns the packet to again until it returns it to finish The program: graph and runs, 11.1
УП-07 frame «For each» for_each primitive an element of a list is a round of its own; a primitive, since there is no counter in the graph The program: graph and runs, 11.2

2.5 Data

Table 8 — Data

Code Name In code Class Definition Where described
УП-08 take a field take primitive one field of the packet becomes the packet The program: graph and runs, section 21
УП-17 stamp stamp primitive the time the run began and a record number that does not repeat; a cold source, repeated on resume The program: graph and runs, section 25
УП-18 pick pick primitive the records of a list that pass a test from a closed set, and their number The program: graph and runs, section 26
УП-20 time moment primitive a moment by the calendar: from a date in the packet or the start of the run, after so many days, at such an hour The program: graph and runs, section 27
УП-21 template template primitive a text into which fields of the packet are put; it puts in, it does not count The program: graph and runs, section 28

2.6 State

Table 9 — State

Code Name In code Class Definition Where described
УП-09 variable variable primitive gives the current value of a variable; a cold source The program: graph and runs, sections 6, 7
УП-10 write write primitive puts the packet or its field into a variable and passes the packet on The program: graph and runs, section 7
УП-11 «First time?» first_time primitive by indivisibility tests and remembers in one action, with no gap between the test and the writing The program: graph and runs, section 20

2.7 Waits

Three forms of one primitive: waiting for time, for the person and for a signal. The forms are made alike (opening the wait, receiving what came, closing); each has its own term and its own record in the checkpoint.

Table 10 — Waits

Code Name In code Class Definition Where described
УП-12 «Wait» wait primitive, transferring the branch waits until the named moment by real time The program: graph and runs, section 19
УП-13 «Question» ask primitive, transferring the branch waits until the person answers on the pulpit The program: graph and runs, section 9
УП-14 «Wait for a signal» signal primitive, transferring the branch waits until a signal with this name comes from outside The program: graph and runs, section 22

3 Shorthands and notation

They are built of primitives and bring no new meaning. They are kept because they read better than their unfolded form.

Table 11 — Shorthands and notation

Code Name In code Class What it unfolds into Where described
УС-01 choice choice shorthand a chain of equality conditions with named outputs The program: graph and runs, section 8
УС-02 switch switch shorthand a choice whose subject of comparison is a variable The program: graph and runs, section 8
УС-03 call of a process process shorthand a macro: the graph of the called one is unfolded inside before the run; the inputs, outputs and parameters are those the called one declared The program: graph and runs, section 18
УС-04 result result shorthand the second half of a call; it disappears when unfolded The program: graph and runs, section 18
УС-05 constant constant shorthand the value of a parameter given by a link The program: graph and runs, sections 4, 6
УС-06 note note shorthand nothing: a place of the graph with the person's words for whoever reads it The workshop, 5.1

Layers, not kinds of nodes: a group (The program: graph and runs, section 17), a frame as a border (The program: graph and runs, section 11), a shared object (The program: graph and runs, section 16).

Notes on the canvas and points on links are layers too, not kinds of nodes: a note does nothing, and a point only leads a link around — the link itself serves as identity (The workshop, 5.1). A note lies in the document among the nodes as the shorthand kind note (УС-06) — so the canvas places, moves, puts into a group and removes it like a node — but it has no ports, and a run never comes to it: it is a shorthand for an empty place of the graph; a point is the field via of a link (File formats, section 5).

4 Transferring elements: borders of worlds

A transferring element is a place where work crosses a border and the laws of the graph do not act beyond it. Each such element must answer five questions.

Table 12 — Transferring elements: borders of worlds

Code Border Term Refusal Retry Cancel Ownership
ПГ-01 module (УП-02) timeout_ms of the manifest the output failed retry and the declared idempotence the method cancel the work folder of the run
ПГ-02 the person (УП-13) timeout_ms, 0 — no term the output declined the question opens anew after a failure closes with the run the answer belongs to the run
ПГ-03 a signal from outside (УП-14) timeout_ms, 0 — no term — a signal is not kept: with no receiver it is dropped with a record removed with the run the data of the signal belong to the run
ПГ-04 the clock: schedule and timer (УП-01) the moment itself — what was missed while the machine was stopped gives one run by switching the program off —
ПГ-05 the clock: pause (УП-12) the moment itself — the moment lies in the checkpoint removed with the run —
ПГ-06 the pulpit (УП-01 with source: pult) — — the overlap rule overlap — the data of the element
ПГ-07 file and artifact — a refusal of the module that opened it — — a file does not change after it appears; a file given by the person lives as long as the place it was given to (The program: graph and runs, 24.4)
ПГ-08 call of a process (УС-03) none of its own: unfolded before the run a refusal inside is a refusal outside — shared with the caller shared with the caller
ПГ-09 another program (УП-15; УП-01 with source: message) none of its own: sending does not wait for the receiver the output unsent with the reason none: a message obeys the overlap rule of the receiver, a signal is not kept — the data pass to the receiver; the files they name are copied into its files/
ПГ-10 the person: showing (УП-16) — does not refuse: a field missing from the packet is shown as missing, the run goes on — — what is shown is kept by the program while it is on
ПГ-11 the person: notification (УП-19) — does not refuse — — a notification is not kept: it is seen by whoever is at the window

5 The intermediate: a library of ready pieces

Intermediate elements are built of primitives, repeat in different areas and do not belong to the platform. The mechanism of the library is the call of a process (УС-03); the library needs no changes of the platform.

Table 13 — The intermediate: a library of ready pieces

Code Pattern What it is built of
ПБ-01 debounce: «N after the last edit» overlap replace + pause
ПБ-02 «one at a time», a print queue overlap queue
ПБ-03 «whoever is first» merge-OR (УП-05)
ПБ-04 rate limiting frame «For each» + pause
ПБ-05 a finite automaton a tick event + switch + write
ПБ-06 escalation a question with a term + a signal with a term
ПБ-07 «gather over a window of time» a list variable + schedule; merge has no count
ПБ-08 membership in a list (∈) going through a list + comparison
ПБ-09 folding a list into one a round + a variable of the run
ПБ-10 an ordered fan a chain instead of a fan-out

6 Laws of the medium

The laws of the medium are not elements but properties of the medium the elements work in.

Table 14 — Laws of the medium

Code Law Essence Where described
ЗС-01 the input queue each input port has a FIFO of length graph.queue_depth; overflow is an error, not a silent loss The program: graph and runs, 10.1
ЗС-02 the input rule all waits for all inputs, any takes the first; what is not chosen goes to overflow or is recorded as dropped The program: graph and runs, 10.3
ЗС-03 the overlap of runs queue, skip, replace, parallel — the behaviour if a run of this event is still going The program: graph and runs, section 5
ЗС-04 acyclicity an arrow back only inside a frame; constant work is given by a program that is on, not by a ring in the graph The program: graph and runs, section 3
ЗС-05 totality frames are bounded, recursion is forbidden, a step of a module has a term: every run is finite, except a wait without a term (ПГ-02, ПГ-03) —
ЗС-06 reproducibility the path of a run repeats on resume; so there is no randomness in the graph — it is in a module The program: graph and runs, section 14
ЗС-07 two places of nondeterminism merge-OR (УП-05) and the input rule any are the only places where the result depends on the order of arrival —
ЗС-08 conservation of flow a node waiting for packets from two paths of one fork will never fire: the warning never_fires before the run and the record stalled after The program: graph and runs, 10.4
ЗС-09 hot and cold a cold input is not waited for: the value is read at the moment of the step The program: graph and runs, section 6
ЗС-10 the rule of extending the set a new kind of node is justified only if it is a primitive; the rest is a subgraph or a module The program: graph and runs, section 3, rule 8

7 Boundaries of the node system

Table 15 — Boundaries of the node system

Code What is absent Grounds
ВГ-01 arithmetic and expressions new operations on values are endless; their place is a module (ЗС-10). Two operations the same for everyone are taken out of modules — a shift by the calendar (УП-20) and putting fields into a text (УП-21); the platform carries no common brick modules for the rest
ВГ-02 unbounded search, recursion the condition of the end of a run (ЗС-05)
ВГ-03 undoing what was done, compensation none of fifty scenarios needed it
ВГ-04 priorities of jobs the queue is strictly FIFO (ЗС-01)
ВГ-05 randomness in the graph would break reproducibility (ЗС-06)
ВГ-06 an explicit break of a run is expressed by a refusal of a module and is therefore not a primitive

8 Figures

Table 16 — Figures of the node system

Measure Value
kinds of nodes 26
of them carrying primitives 20
of them shorthands 6
primitive operations 21
transferring borders 11
laws of the medium 10
ready pieces for the library 10
named boundaries 6

The set of kinds is closed. Adding a kind is a change of the documentation and by the law ЗС-10 is allowed only with a proof that the kind is a primitive.

Appendix A (informative). Reference of the kinds of nodes

The reference holds one card for each kind of node: its purpose, the inputs and outputs with their meaning, its class, the parameters the person sets, and what is needed for drawing.

The reference is a snapshot of the working platform. The ports and texts are taken from the working platform (process.kinds, process.node.template, i18n.catalog). What decides is the code and The program: graph and runs; the catalogue and the classes are in sections 1–8 of this document. When they disagree, the reference is taken anew rather than corrected by hand. make ci makes sure all the kinds the engine knows are here.

Marks of ports. *required* — without a packet at this input the node does not fire; *optional* — the port always exists, but a packet goes along it only if a link is drawn from it.

A.1 What is needed for drawing

Seven properties on which the look of a node depends more than on its meaning.

Table A.1 — Properties of the kinds of nodes that matter for drawing

Property Kinds Why it matters for drawing
no inputs — begins by itself event, variable, constant, stamp nothing comes to them from the left; they are sources
no outputs — an end result nothing leaves it to the right
the number of ports is set by the person merge (inputs), choice and switch (outputs) one and the same kind will have a different number of points on the canvas: from one to many
the number of ports is set by the manifest module two module nodes side by side have different ports; plus failed, which the graph gives
the number of ports is set by the called process call of a process two calls of different processes have different ports, named in the person's words
an area, not a box frame «Repeat», frame «For each» their ports face outside and inside: the body lies in the area
a branch may stand «Wait», «Question», «Wait for a signal» a waiting look is needed: the node is not working and has not finished, it stands

A cold link comes from a variable or a constant. The node at its end does not wait for the link but reads the value at the moment of the step. On the canvas a cold link is drawn dashed (The workshop, 5.3).

A parameter from a variable ({ "variable": "<id>" }, The program: graph and runs, section 15) is read the same way — at the moment of the step. On the canvas it stands on the node as a row of the variable with a reading mark (The workshop, 5.3): the canvas shows where the node takes its data from.

The family of a kind tells what the node is for and sets the colour of its head on the canvas (The workshop, 5.3). There are five families of work: beginning and end (start) — event and result; work (work) — module, «Send», «Notify» and the call of a process; flow (flow) — condition, choice, switch, «First time?», merge and both frames; data (data) — variable, constant, write, «Take a field», «Show», «Stamp», «Pick», «Time» and «Template»; waiting (wait) — «Wait», «Question» and «Wait for a signal»; and a sixth, not of nodes of work — note (note). The family is named by the kind itself in its description (family, Methods of the graph, section 1); a group has a head of its own.

A.2 Cards

A.2.1 УП-01 · Event · event

What it does. Event: work starts with it. The pulpit, the clock, switching the program on, a call from another process, a message of another program or a value a person changed sets it off.

Table A.2 — УП-01 · Event · event

Field Value
class primitive · transferring
inputs —
outputs event — The data a run starts with.
number of ports no inputs: begins a run
the person sets name, overlap, source, variable; for timer — interval_ms; for schedule — at, weekdays, month_days; what the event takes — takes
for drawing the meaning changes with the kind of source: pult, start, timer, schedule, call, message, change; for call the parameter name is the name of the input at the node that calls the process; for change the parameter variable is the variable the event watches

A.2.2 УП-02 · Module · module

What it does. A module does the work: it has its own inputs, outputs and settings.

Table A.3 — УП-02 · Module · module

Field Value
class primitive · transferring
inputs —
outputs failed optional — The module's refusal goes out here when a link leaves this output: the run does not fail but goes on along this branch. The data is the error code, its text and what came in. Without a link the refusal stops the run, as usual.
number of ports the ports are set by the manifest of the module
the person sets parameters — by the schema of the manifest of the module; fields of the node itself: memory, for a node of a service — overlap
for drawing failed is always there, but carries a packet only if a link is drawn from it

A.2.3 УП-03 · Condition · condition

What it does. A condition: data goes the yes or the no way.

Table A.4 — УП-03 · Condition · condition

Field Value
class primitive
inputs input required — The data the condition checks.
outputs true — Data goes here when the condition holds.
false — Data goes here when it does not.
number of ports always two outputs
the person sets predicate
for drawing looks at the packet or at a variable — by the field variable

A.2.4 УП-04, УП-05 · Merge · merge

What it does. Merge: gathers data from several inputs into one.

Table A.5 — УП-04, УП-05 · Merge · merge

Field Value
class primitive (two: all and first)
inputs input required — One input of the merge. If several links lead here, choose how to gather them.
outputs success — The data gathered from several inputs.
number of ports the inputs are named by the person — one per source
the person sets join_key, policy, shape
for drawing input in the template is only the first; the others have names of their own

A.2.5 УП-06 · Repeat · repeat

What it does. The repeat frame: the nodes inside it run again until it says done.

Table A.6 — УП-06 · Repeat · repeat

Field Value
class primitive
inputs input required — The data the first round starts with.
again — The body sends data back here for another round.
finish — The body sends data here when the rounds are done.
outputs body — From here data goes to the nodes inside the frame.
done — The repeat is over: data goes on.
number of ports a frame: an area, not a box
the person sets max_iterations, max_loop_ms, on_limit
for drawing the ports face both outside (input, done) and inside (body, again, finish)

A.2.6 УП-07 · For each · for_each

What it does. The frame «For each»: the nodes inside work through the elements of a list one by one, and the frame collects the results.

Table A.7 — УП-07 · For each · for_each

Field Value
class primitive
inputs list required — The list the frame walks through element by element.
result — The result of one element — the body brings it back to the frame.
outputs item — One element of the list — it goes into the body of the frame.
done — The list of results in the order of the elements, when every one has been through.
number of ports a frame: an area, not a box
the person sets parallel, path
for drawing outside list and done, inside item and result

A.2.7 УП-08 · Take a field · take

What it does. Take a field: takes one field of the data and makes it new data. The rest is dropped. The field is named by the last part of the path, or by the name you give it.

Table A.8 — УП-08 · Take a field · take

Field Value
class primitive
inputs input required — The data one field is taken from.
outputs value — Data of the one field taken.
number of ports one input, one output
the person sets as, path
for drawing the only operation on data in the graph

A.2.8 УП-09 · Variable · variable

What it does. Variable: hands out the value it holds now. A node does not wait for it — it takes the value at the moment of its step.

Table A.9 — УП-09 · Variable · variable

Field Value
class primitive
inputs —
outputs value — The value the variable holds now. The node it comes to does not wait for it.
number of ports no inputs: a cold source
the person sets variable
for drawing a link from it is cold: the node at the other end does not wait for it

A.2.9 УП-10 · Write · write

What it does. Write: puts the data into a variable and passes it on.

Table A.10 — УП-10 · Write · write

Field Value
class primitive
inputs value required — The data that will go into the variable.
outputs success — The same data, on along the graph.
number of ports one input, one output
the person sets mode, path, variable; for put and remove — key; for spread — variables instead of variable
for drawing the packet passes through, the value goes into the variable

A.2.10 УП-11 · First time? · first_time

What it does. First time?: looks whether this value has been seen before. It has not — the output «yes», and the value is remembered in the list; it has — the output «no». The data goes on unchanged.

Table A.11 — УП-11 · First time? · first_time

Field Value
class primitive by indivisibility
inputs input required — The data we ask about: have we seen it before?
outputs true — The first time: the value has just been remembered.
false — Seen before.
number of ports always two outputs
the person sets path, variable
for drawing the only node that both tests and changes the state

A.2.11 УП-12 · Wait · wait

What it does. Wait: this branch stands still for the time given while the others go on. The pause is written into the checkpoint, so after a break the branch waits out what is left instead of starting over.

Table A.12 — УП-12 · Wait · wait

Field Value
class primitive · transferring
inputs input required — The data that waits here and goes on unchanged.
outputs done — The time is up: the same data goes on.
number of ports one input, one output
the person sets wait_ms
for drawing a branch may stand: a waiting look is needed

A.2.12 УП-13 · Question · ask

What it does. A question to a person: this branch waits for an answer on the pulpit or on the node itself, the others go on working.

Table A.13 — УП-13 · Question · ask

Field Value
class primitive · transferring
inputs question required — The data a person will see as the question.
outputs answer — The question together with what the person answered.
declined — The person refused to answer, or said no.
timeout — No answer came: the term ran out.
number of ports always three outputs
the person sets choices, kind, timeout_ms; for text — fill: a field of the data whose text already stands in the answer
for drawing a branch may stand; the only node that shows itself on the pulpit

A.2.13 УП-14 · Wait for a signal · signal

What it does. Wait for a signal: the branch stands until a signal of this name comes from outside, while the others go on. A module, the pulpit or another process sends it. Nothing came in time — the branch leaves by «timed out».

Table A.14 — УП-14 · Wait for a signal · signal

Field Value
class primitive · transferring
inputs input required — The data the branch stands to wait with.
outputs signal — The signal came: the data it waited with, and the data of the signal.
timeout — No signal came in time.
number of ports always two outputs
the person sets key, name, timeout_ms
for drawing a branch may stand: it waits for the outside

A.2.14 УП-15 · Send · send

What it does. Send data to another program — or to this one. A message starts its run by its event «message» of the same name; a signal wakes its branch that waits for the signal. When nobody takes it, the data leaves by «unsent» with the reason.

Table A.15 — УП-15 · Send · send

Field Value
class primitive · transferring
inputs input required — What to send.
outputs sent — Taken: the data goes on as it was.
unsent — Not taken: the reason and the data. The program is off, there is no event or waiting branch of that name, or the event did not take a new run.
number of ports always two outputs, exactly one goes
the person sets key, mode, name, process_id or to
for drawing the link goes beyond the program: the receiver is another program, by name

A.2.15 УП-16 · Show · show

What it does. Show: what came is seen right on the node, and where it is put in the interface, there too. The data goes on unchanged, so the node stands at the end of a branch or in its middle alike.

Table A.16 — УП-16 · Show · show

Field Value
class primitive · transferring
inputs value required — The data the node shows.
outputs success — The same data further along the graph, unchanged.
number of ports one input and one output: it stands at the end of a branch and in its middle alike
the person sets path
for drawing under the rows of the ports — a view of what came: text, number, list, picture, sound, video, file

A.2.16 УС-01 · Choice · choice

What it does. Choice: the data leaves through the output of the case whose value matched; none matched — through «other».

Table A.17 — УС-01 · Choice · choice

Field Value
class shorthand
inputs input required — The data the choice sorts between its cases.
outputs other — The data that no case matched.
number of ports the outputs are named by the person: the cases plus other
the person sets cases, path; variable — test the value of a variable, not the data
for drawing the number of outputs from one to many

A.2.17 УС-02 · Switch · switch

What it does. Switch: a fork not by the data but by a variable — the one a person sets on the pulpit. The data goes on unchanged; a value matching no case leaves by «other».

Table A.18 — УС-02 · Switch · switch

Field Value
class shorthand
inputs input required — The data to send one way or another by the position of the switch.
outputs other — The value of the variable matched no case.
number of ports the outputs are named by the person: the cases plus other
the person sets cases, variable
for drawing the same as choice, but looks at a variable

A.2.18 УС-03 · Process · process

What it does. Calls another process as a node: its graph is unfolded here before a run. The inputs and outputs of the node are the inputs and outputs of the called process, under their names. Change the called process, and the call gets the change at the next run.

Table A.19 — УС-03 · Process · process

Field Value
class shorthand
inputs one for each event call of the called process, under the name of the event; input — for an event without a name and for a call that has not yet named a process
outputs one for each «Result» node of the called process, under the name of the node; success — for a node without a name and for a call that has not yet named a process
number of ports set by the called process
the person sets process_id, values — values of the variables of the called process
for drawing inside is someone else's graph; it is unfolded before the run. On the head is the name of the called process; in a run the node shows what the nodes of the unfolded graph do

A.2.19 УС-04 · Result · result

What it does. What this process answers with when a node of another process calls it. The data that comes here leaves the calling node — by the output named as this node is. There may be several «Result» nodes, each with a name of its own.

Table A.20 — УС-04 · Result · result

Field Value
class shorthand
inputs value required — The data this process answers the caller with.
outputs —
number of ports no outputs: an end
the person sets name — the name of the output at the node that calls the process
for drawing only a process that is called has it

A.2.20 УС-05 · Constant · constant

What it does. Constant: hands out the value written in it. A node does not wait for it either.

Table A.21 — УС-05 · Constant · constant

Field Value
class shorthand
inputs —
outputs value — The value written in. The node it comes to does not wait for it.
number of ports no inputs: a cold source
the person sets value, type
for drawing a link from it is cold

A.2.21 УП-17 · Stamp · stamp

What it does. Stamp: the time the run began and a number of a record that is never repeated. The node it comes to does not wait for it.

Table A.22 — УП-17 · Stamp · stamp

Field Value
class primitive
inputs —
outputs value — { time, id }: the time the run began and the number of this step.
number of ports no inputs: a cold source
the person sets —
for drawing a link from it is cold

A.2.22 УП-18 · Pick · pick

What it does. Pick: the records of a list that pass a check, and how many they are.

Table A.23 — УП-18 · Pick · pick

Field Value
class primitive
inputs input required — The data what is found is added to.
outputs success — The same data with the field of what was found: { items, count }.
number of ports one input, one output
the person sets variable or list, test, as
for drawing looks into the list of a variable or of the packet; the packet goes on with what was found

A.2.23 УП-19 · Notify · notify

What it does. Notify: the person sees a notice over the window, whatever tab or window they are in — a reminder, a new letter, the end of a long work. The data goes on unchanged.

Table A.24 — УП-19 · Notify · notify

Field Value
class primitive · transferring
inputs value required — The data the text of the notice is taken from.
outputs success — The same data further along the graph, unchanged.
number of ports one input and one output: it stands at the end of a branch and in its middle alike
the person sets title, path
for drawing the head of the family «work»: the node acts outward, on the person

A.2.24 УП-20 · Time · moment

What it does. Time: a moment from the start of the run or from a date in the data — so many days on, at such an hour. The data goes on with the moment added as a field.

Table A.25 — УП-20 · Time · moment

Field Value
class primitive
inputs input required — The data the moment is added to; a field of it may hold the date it is counted from.
outputs success — The same data with the field of the moment: a date and a time by the clock of this machine.
number of ports one input, one output
the person sets from, days, at, as
for drawing the packet goes on with the moment added

A.2.25 УП-21 · Template · template

What it does. Template: a text with fields of the data put in. It does not count, it only puts in. The data goes on with the text added as a field.

Table A.26 — УП-21 · Template · template

Field Value
class primitive
inputs input required — The data whose fields are put into the text.
outputs success — The same data with the field of the finished text.
number of ports one input, one output
the person sets text, as
for drawing the packet goes on with the text added

A.2.26 УС-06 · Note · note

What it does. Note: your words on the canvas about the program — what is done here and why. It does nothing and takes no part in a run.

Table A.27 — УС-06 · Note · note

Field Value
class shorthand
inputs —
outputs —
number of ports no ports: no link ever comes to it
the person sets text
for drawing under a head of its own colour — a text, line by line, from two to eight lines