Feed screen standard

Table of Contents

1. Summary

A feed is a record that produces market data: it holds a process, and while it runs, the process makes a tick at a fixed rate. The FX price feed screen is the first feed screen, and its shape is the standard for every asset class that follows: IR curves, and any other kind of synthetic feed.

A feed is still a record. Everything this page does not state follows the Record screen standard: the list and its paging, the header, the edit dialog, change reasons, delete, the states and the words. This page adds what a feed has and a plain record does not: a run state, a process edited as one set, an engine that decides what the numbers mean, previews, live ticks, and the quant help that makes the numbers readable.

Each rule names the shared part that carries it, so a new feed screen gets the rule by using the part.

A feed here is a generator of the simulator. Every generator belongs to the system tenant and the system party, and it simulates one vendor instrument of a real provider such as Bloomberg or LSEG. A party consumes the data through a subscription and a route and never owns a generator. See Generators belong to the system tenant and the system party. A feed browser organises generators by provider and kind and holds the per-kind screens of this page as its leaves, at a scale of many thousands of generators.

2. Detail

2.1. Where this standard applies

A feed screen is a screen whose subject is the feeds of one kind: it lists them, starts and stops them, opens one, and edits its process. The FX price feed screens and the IR curve feed screens under Market data are feed screens.

These are not feed screens:

  • The collection screen. A collection holds feeds and starts and stops them as one; it is a record screen with its own task.
  • The model catalogue. Process types are reference data.
  • The Qt market simulator, which The market simulator screens describes.

2.2. Words

Word Meaning
Feed The record: what it simulates, its rate, its engine and its run settings
Process The parts the engine draws from, such as an FX feed's Gaussian components
Engine The price process that reads the parts: geometric, arithmetic or mean reverting for FX
Draft The process as it stands on the screen, before Save
Run The feed producing ticks. A feed is running or stopped
Tick One value the running feed produced, with its time
Share A part's weight over the sum of the weights, as the engine normalises it

The tab that edits the process carries the Qt editor's name for it. For FX it is Price behaviour.

2.3. What a feed kind declares

A kind of feed declares, once, in a FeedKind (marketdata/feedKind.ts):

  • its record resource, its entity type, the address of its screens and the block of words it speaks in;
  • its fields, the fields its edit dialog offers, what a new feed starts with, the fields that follow from the others, and the rules across fields;
  • how the feed is named in a title, such as a pair or a curve, and the line under the name;
  • its columns after the status, and the facts its Details tab adds;
  • the rows a feed owns, with the resource of each, so the screens read them, delete them with the feed and draw their history;
  • its own tabs, between Details and History, each a function of the feed, whether it runs, whether the person may write it, and the rows it owns;
  • the tab a new feed opens on.

The list, the page, the add, edit and delete dialogs, the run controls and the History tab are then drawn by FeedsPage and FeedPage (marketdata/FeedScreens.tsx), the same for every kind. A kind also states the engines it offers, what each number of a part means, the server operations its tabs call, the subject its ticks are published on and the permission that gates it.

2.4. The list is the dashboard

The list follows the record standard, and it is also where feeds are run.

  • A Status column shows Running or Stopped as a tag. The screen reads the running feeds every five seconds, because a feed can start or stop from anywhere.
  • A writer gets a choice box on each row, and Start chosen (n) and Stop chosen (n) in the list header.
  • Each chosen feed is its own call, so one refusal does not stop the others. The answer counts what started or stopped and names each refusal with the server's reason. A feed is named by its source name, never by its id.
  • Starting a whole collection belongs to the collection screen.

2.5. The feed page

2.5.1. Header

  • The flag of what the feed simulates, such as the pair, then the feed's name.
  • The line under the name: the key, the version and the engine, such as "EUR/USD · version 3 · Geometric".
  • The status tag, then Start or Stop, then Edit and Delete.
  • No access mark. The actions offered already say what the person may do.

2.5.2. Tabs

Tab What it holds
Details The feed's fields, as the record standard draws them
The process tab The process, the engine, and the previews. For FX: Price behaviour
Ticks The last ticks of the feed
History One stream of the feed and its parts

2.5.3. Edit, add and delete

  • The edit dialog does not offer the engine. The engine changes on the process tab, where the process is converted with it.
  • The add dialog offers the engine, so a new feed starts with one. A new feed opens on the process tab.
  • Each field of the form can carry help, shown under it. A choice is explained by its option.
  • Delete stops the feed, deletes its parts, then deletes the feed.

2.6. The process tab

2.6.1. Layout

[ 2 unsaved changes ]        Engine [Geometric ▾]  [Add] [Discard] [Save]
┌─────────────────────────────────────────────────────────────────────┐
│ # Description            Profile   μ        σ        w      Share   │
│ 0 Primary · calibrated…  Normal    0        0.001    0.95   95.0%  ↑↓ Delete │
│ 1 Tail · 4x primary…     Custom    0        0.004    0.05    5.0%  ↑↓ Delete │
└─────────────────────────────────────────────────────────────────────┘
┌ Return distribution ─────────┐ ┌ Sample paths ────────────────┐
│ chart                        │ │ chart                        │
│                              │ │ price · ticks · paths · seed │
└──────────────────────────────┘ └──────────────────────────────┘
ⓘ The engine's note
  • The toolbar holds the unsaved count, or "No unsaved changes.", the engine, and Add, Discard and Save. Buttons are one word.
  • The list spans the full width. The previews sit side by side below it, and stack on a narrow screen. The engine's note sits under the previews.

2.6.2. The list

  • The list is read only. A row opens the part in a dialog.
  • The description shows its name highlighted and its note subdued: the text before the first colon is the name. A long description ends in an ellipsis, with the whole text in its tooltip.
  • Numbers are right aligned in the mono face.
  • A computed column states what the engine does with the numbers. For FX, the Share column gives each weight as a percentage of the sum, and its header tooltip gives the sum. An engine that reads no shares has no such column.
  • Every column header has a tooltip in the engine's terms, and every row a tooltip that says what one part means to the engine.
  • Each row has ↑, ↓ and Delete. The first row cannot move up and the last cannot move down.

2.6.3. Unsaved changes

Nothing is written until Save, and what is not saved is visible:

Change Mark
A new part The row tinted, and tagged New
A changed value The cell tinted, and the row tagged Changed
A moved part The row tagged Moved
A deleted part The row kept, struck through, tagged Deleted, with Undo
A changed engine The engine choice outlined

Discard puts the saved process and engine back.

2.6.4. The part dialog

  • The description is a text area of four lines, with a hint for the "Name: note" form.
  • Each number has the engine's help under it, and the dialog refuses a value that is not a number or is negative before Done.
  • Done puts the part back into the draft. It writes nothing.

2.6.5. Saving

Save is enabled while there are changes and no problems. It opens a dialog:

  1. One line per kind of change: the engine change, such as "Engine: Geometric → Arithmetic.", and the counts added, changed and deleted.
  2. The change reason and commentary, or the new record note when every change is new.
  3. When the feed applies the change. A running feed keeps the process it started with, so the dialog says "The feed is running on the old mixture." and offers Restart it to apply, ticked. A stopped feed is told "It applies on start."

The save writes the feed's engine first, then deletes the removed parts, then writes the changed parts, all under one reason. A restart, when chosen, stops and starts the feed after the writes.

2.6.6. The engine

The engine decides what the numbers of a part mean. Changing it changes the meaning of the saved process, so the screen converts the draft with it:

  • The screen asks the server to convert the draft. The conversion is never computed in the browser.
  • The converted values show as unsaved changes. A notice says what was converted and at which price, and says when a preview price stood in for a feed with no fixed price.
  • For FX, the server operation is convert_fx_mixture: μ and σ scale by the initial price between log-returns and price units; into the mean reverting engine only the first part stays, with κ from a 15 minute half-life and no μ; out of it the one part takes the whole weight.

2.6.7. Previews

  • The previews read the draft, not the saved process, so a person judges a change before saving it.
  • The distribution is drawn per part, dashed, and as the whole.
  • The sample paths come from the server's simulation, with their settings under the chart: the initial price, the ticks, the paths and the seed with Reseed. The screen waits 300 ms after typing before it asks.
  • Neither preview saves anything.

2.7. The process tab of a curve feed

A curve feed's process is the engine and a fixed set of parameters, so the tab is the process tab above with the parts that follow from that.

  • The toolbar is the same: the unsaved count or "No unsaved changes.", the engine, Discard and Save. There is no Add, and a row has no ↑, ↓ or Delete, because the engine states which parameters it reads.
  • The table lists the engine's parameters, read only: the parameter with its symbol and the value. Each row's tooltip is the parameter's description.
  • A click on a row opens the parameter in a dialog with the description and the value. What the parameter accepts, such as "At least 0." or "Between 0 and 1.", is the tooltip of the field, and the dialog refuses a value outside it before Done. Done puts the value back into the table and writes nothing.
  • A parameter with no saved value is tagged New and shows the engine's default. A value that differs from the saved one is tinted and tagged Changed. A value the engine refuses is shown in red, and Save waits.
  • A change of engine replaces the parameters, and a notice says that the old engine's parameters are removed when the process is saved.
  • The previews below the table price the curve at the template's tenor entries and draw sample short-rate paths, both from the values on the screen.
  • Under each number the table says what it means in plain words: the half-life of κ, the rate behind θ and the initial rate, and the yearly move behind σ. The server works these out, so the screen does no model arithmetic.

2.7.1. Notices and toasts

News of an action does not take a place in the page. A conversion that changed the person's numbers, such as a change of engine or a switch to Simple, shows as a toast. So does the sentence that says what the Simple answers make of the model (the curve slopes up, or the price has no trend), which a new answer replaces in the bottom right corner (ui/Toasts.tsx). It has a close button. Information leaves by itself after ten seconds, and a warning stays until the person closes it. A fact that stays true, such as an engine that can take a price below zero, is also marked where it applies: a Can go below zero tag beside the engine, with the full explanation as its tooltip. A closed toast is not lost, because the tag remains.

2.7.2. Simple and Advanced

A process tab offers two ways to edit the same numbers. Advanced is the table above, the engine's own parameters. Simple is for a person who does not know the model, and it asks plain questions in place of the table.

  • The choice is a switch on the toolbar. It is one choice for the whole web application, kept in the browser. A new person starts in Simple, and a person who picks Advanced stays in Advanced on every screen that offers both (EditingMode.tsx).
  • A curve feed asks four questions: where rates are today, where they settle in the long run, how fast they come back (a half-life in years, with the words Slow, Medium and Fast), and how far they move in a year (basis points, with the words Calm, Normal and Stressed). A sentence under the answers says what they make of the curve: it slopes up, down or is flat. A line under the toolbar says in plain words what the engine does.
  • The server converts both ways (synthetic.v1.ops.convert_ir_parameters; the FX mixture conversion, convert_fx_mixture, is its counterpart). Each engine reads σ in its own unit, and Black-Karasinski reads θ as a logarithm, so the screen never converts. An answer goes through the server and into the same draft the table edits. Save, Discard and the previews work the same from either mode.
  • The same switch appears on the screens that draw ORE parameters, settings and convention terms, where it decides how much documentation shows rather than how a person edits. The choice is still one, and each screen names it in its own words; the ORE element and leaf screen standard states that meaning.
  • Switching from Simple to Advanced loses nothing. A feed whose parameters have no simple form, such as a reversion speed of zero or a Two-Factor Gaussian feed with a second factor set by hand, shows the table in either mode, with a note that says why.
  • A warning appears when the parameters allow a risk, such as a Cox-Ingersoll-Ross rate that can touch zero.
  • A field whose value differs from the saved one is tinted, as a changed cell of the table is.
  • The FX price behaviour tab offers the same switch (FxSimplePanel.tsx). Its questions are per hour, so they do not depend on the feed's rate: which way the price drifts, how far it moves, and how often it jumps; the mean-reverting engine asks how long the price takes to come half way back, and how far it moves. The server converts both ways (synthetic.v1.ops.convert_fx_simple). The simple form of a mixture is one primary component and, if the feed jumps, one jump regime that has no drift and is four times as wide.
  • Switching to Simple never leaves a dead end. Values that the simple form states exactly stay as they are. Values that it only approximates, such as three hand-set components, or a second factor and a correlation set by hand, are converted to the closest simple form, and a notice says what changed: how many components became how many, the jump share, or the factors that were set. The change is only in the draft. Save writes it, and Discard brings the old values back. Values with no simple view at all, such as a reversion speed of zero, show the table with a note that says why.

2.8. The Ticks tab

┌ Ticks shown [200▾]  LAST PRICE  TIME  MOVE (200 TICKS)   ☐ EMA 20  [Export CSV] ┐   ┌ PROCESS  [Geometric] ┐
├ EUR/USD synthetic price path              High 1.17652  Low 1.17601 ┤   │ 1800 ticks per hour  │
│ price chart, axis on the right, grid, fill                          │   │ #0 Primary   w 0.95  │
│                                                                     │   │ note, subdued        │
└─────────────────────────────────────────────────────────────────────┘   └──────────────────────┘
  • A strip of labelled figures over the plot: the ticks shown, the last price, its time and the move over the ticks shown, green or red.
  • The chart card heads with what it shows and the high and the low.
  • The price chart has its values on the right, a grid of labelled levels, a light fill under the line, and labels in the page's 12 px mono at any width.
  • An optional moving average, an EMA over 20 ticks, drawn dashed.
  • Export CSV hands the ticks shown to the browser.
  • A column beside the plot shows the process that made the ticks: the engine, the rate, and each part as a card with its name highlighted, its note subdued, its weight in the part's colour, and its other numbers.
  • A running feed's ticks are read again every two seconds.
  • The tab says what it can and cannot show. The web server keeps the last 500 ticks of each running feed from when it began to listen, and forgets a run when the feed stops, so the lead says so.

2.9. The Ticks tab of a curve feed

A tick of a curve feed is one pillar of a curve. The feed publishes a curve as one tick for each tenor entry of the template, in template order, all with the time of the batch, so the ticks that share a time are one curve. The web server keeps the oresmd URI of each tick, and the screen groups by time (irTicks.ts). A batch with a pillar missing, which the server heard in part, is not a curve and is not drawn.

  • The strip shows the history, the time of the newest curve, its short end and long end, and the slope between them in basis points, green or red.
  • One chart, the one the Qt market simulator draws: the tenors of the curve along the bottom, short end to long end, each named under its point, and the rate up the side, with a margin of a tenth of the range. The newest curve is bold and green. The curves before it are overlaid, thinner, grey-blue and fading with age: the oldest is the faintest, and none fades below 40 of 255. Every point has a dot. The legend under the chart says so: "Newest curve bold; older snapshots overlaid, fading with age."
  • The history is a number from 1 to 20, five by default, as in the Qt window. It is the number of recent curves to overlay.
  • Export CSV hands the curves shown to the browser, one row for each curve and one column for each pillar.
  • A column beside the plot shows the process that made the curves: the engine, the rate and each parameter with its saved value.

2.10. The Synthetic screen

Synthetic (marketdata/synthetic/SyntheticScreen.tsx) is one screen with two tabs, Dashboard and Provider. Everything on it is synthetic, so no label says so. The Synthetic feeds prototype shows it.

Two facts drive every number, and they are not the same fact.

  • A feed runs when the synthetic service runs a generator for it. The service names every feed it runs by source name, whichever started the feed: an adapter's demand, or an operator's Start. A feed's state, and the tiles that count feeds, come from that set alone.
  • A provider serves when one of its sources serves and the service demands that source at least one id. The provider's own state and the demand count come from that, and no feed's state derives from it.

2.10.1. The dashboard

The dashboard (DashboardTab.tsx) has five tiles and then one row for each provider.

  • The tiles count the providers, the feeds running, the feeds stopped, the ids demanded and the ticks per minute. The two feed tiles count feeds one by one: a feed is in one of them and never in both.
  • A provider row shows what it simulates, its FX and IR counts, its feeds, the state of its source, and the ids demanded of it that are not served. Demand starts a generator; Start and Stop on the row are the operator's test control.
  • A banner counts the ids that are demanded and not served. Show them in the feed tree is gone; the row opens the Provider tab on that provider.

2.10.2. The Provider tab

The Provider tab (ProviderTab.tsx) is the feeds of one provider.

  • A provider combo at the top, then the provider's state, its feed count and Start and Stop, which act on the provider's feeds as the test control.
  • A collection filter, drawn only when the provider holds more than one collection.
  • An asset class combo: All, or one asset class. The grid is one plain list, with no group headers and no separator rows.
  • The grid columns are underlying, enabled, name, engine, frequency and state. The underlying leads. A feed's state is Running or Stopped, and it is the feed's own run, not the state of its provider's source: the source can serve while this feed's generator does not run. The oresmd URI column is gone; the series is reached from the feed's page.
  • There is no folder tree, no pick bar and no oresmd URI column. The lower folders were derived containers for asset class and instrument, and the grid groups by the same properties.
  • A feed's page opens from a row. Its trail is Home, Market data, Synthetic, Provider, the provider and the folders, then the feed.

2.11. History

The History tab is one stream of the feed and every part it holds, drawn as the timeline of the Entity screen specification: the event chart above a rail of one-line entries, each naming its record. Each version older than its record's newest offers Revert to a person who may write it. A part offers no history of its own in the list.

A part deleted from the process is not in the stream, and the tab says so in one line under the timeline.

2.12. Quant logic lives on the server

What the numbers mean is the engine's, and the engine is on the server. A feed screen asks the server for every quant answer that decides a value written to the feed: the sample paths, the conversion between engines, and any calibration. The screen draws what the server answers.

2.13. Words on a feed screen

  • Buttons are one word: Add, Discard, Save, Start, Stop, Undo, Done.
  • Notes are one short sentence. "The feed is running on the old mixture." says what the person needs; a paragraph that explains the engine does not belong in a dialog.
  • The long explanations live in tooltips and field hints, where a person who wants them looks.

2.14. The shared parts

Part Where What it carries
The list RecordList, with syntheticStore Paging, search, sort and columns
Runs marketdata/feedRuns.tsx The running read, the status tag, start and stop of many
The feed kind marketdata/feedKind.ts What a kind states: fields, columns, parts, tabs
The list and the page marketdata/FeedScreens.tsx FeedsPage and FeedPage, for every kind
The process tab, FX marketdata/MixturePanel.tsx The list, the marks, the engine, the previews
The process tab, IR marketdata/IrProcessPanel.tsx The toolbar, the parameter table, the parameter dialog, the curve shape and the paths
The curve template PartsPanel in refdata/records.tsx The tenor entries, as the parts standard sets them
The part dialog marketdata/ComponentDialog.tsx One part with its help
The save dialog marketdata/SavePartsDialog.tsx The reason, the order of writes, the restart, in the words of the kind
The process rules marketdata/mixture.ts, marketdata/processHelp.ts Draft, save plan, changes, shares, profiles
Charts marketdata/LineChart.tsx Lines, the price chart, measured width
Ticks, FX marketdata/TicksPanel.tsx, marketdata/ticks.ts, bff/src/feed-ticks.ts The strip, the chart, the EMA, the CSV, the BFF buffer
Ticks, IR marketdata/IrTicksPanel.tsx, marketdata/irTicks.ts The curves, the slope, the tenor over time, the CSV
History marketdata/FeedHistory.tsx with Timeline One stream of the feed and every kind of part it owns
Conversion ores.synthetic.api/feeds/fx_mixture_conversion.hpp The engine change, on the server

The list, the page, the save dialog and the history take the kind's declaration, as the record parts take a store. The process tab, the part dialog and the ticks panel are still written for the FX mixture; the IR curve kind has a process tab of its own, and a kind with a mixture-like process would share the FX one.

2.15. How today's feed screens conform

Screen Conformance
FX price feeds Conforms. It is the screen this standard was taken from; its feeds are listed in the feed tree of Synthetic
IR curve feeds Conforms: the page with Details, Process, Curve template, Ticks and History, the previews and the unsaved marks. The Ticks tab draws curves, see below. The task Build the IR curve feed screen states the aim

2.16. Building a feed screen for a new asset class

  1. Give the server the kind's resources, with the filter that reads the rows of one parent, and the conversion between the kind's engines and its previews as operations. Test them there.
  2. Write the kind: a FeedKind with its fields, columns, parts and tabs, and two pages that hand it to FeedsPage and FeedPage. Add the routes and the card on the Market data area, and the permission.
  3. Write the kind's own tabs. Take the parts above where they fit.
  4. Write the words of the kind in every language: the titles, the field hints, the engine names and the tab notes.
  5. Check the screen against each section of this page, and add its row to the conformance table.

2.17. Gaps

  • The Ticks tab shows only what the web server heard. The stored observations are written under the feed's series identity, which a feed now names by its oresmd URI; the tab does not read its history from the store yet.
  • The browser still computes some figures it only displays: the shares, the mean reverting half-life and band, the profiles and the distribution curve. Each moves to the server when a screen first needs it from there.

3. See also

Emacs 29.3 (Org mode 9.6.15)