Glossary

Microsoft's free platform for running C# programs on Windows, macOS and Linux.

A tiny version of .NET that runs C# on some microcontrollers, with far fewer libraries than full .NET.

A layer that slides the same small filter along a time series.

The low-power radio standard underneath Thread and Zigbee.

Keeping two app slots and always writing the update into the one that isn't running.

An unfinished checklist line a named owner allows to ship, with a reason, mitigation and expiry.

A list of rules saying which client may read or write which topics.

The Wi-Fi box (usually the router) a device connects to.

The receiver's short "got it" reply to a message.

A BLE device broadcasting short packets so others can discover it.

One number that summarises many readings, such as their average or maximum.

When people get so many alerts that they stop paying attention to them.

Flagging readings that don't look like the ones a device has seen before, without examples of faults.

Any number that grows as a value looks less normal, turned into a decision by a threshold.

A number burned into eFuse that only goes up; images older than it won't boot.

The set of requests a program accepts from other programs, and what it answers.

A space in flash that holds one complete firmware image.

Something an attacker would want or you would hate to lose.

Speeding up a satellite fix by downloading satellite data over a mobile network.

Products that help someone do something a disability or condition makes hard.

Each message is resent until it is confirmed, so it always arrives but may arrive twice.

Each message arrives once or not at all; nothing is ever repeated.

Writing a new copy elsewhere, then switching one small pointer, so data is either all old or all new.

Every way in an attacker can reach and try: ports, topics, radios, the USB socket.

The stage that turns raw audio into a compact picture of frequencies for a model.

A permanent record of who did what and when, such as who sent a command.

Encryption that also notices if the scrambled data was changed.

Proving who you are -- a device showing the broker a username and password or a certificate.

Deciding what an identified device is allowed to do, such as which topics it may publish to.

The server-side software that receives device data, stores it and serves it to apps.

A part of the back end that runs jobs on its own, away from the requests users make.

The longest a device will ever wait between retries.

The standard protocol for heating and ventilation controllers in commercial buildings.

Saving up several readings and writing them in one go, which is much cheaper than one write each.

A BLE device that only advertises, never connects, broadcasting an ID or a reading.

A string a client sends with each request to prove it has logged in; whoever holds it is let in.

Everything an attacker can reach once one device or credential is compromised.

The low-power kind of Bluetooth used by sensors, wearables and phones.

Bill of materials: every part in a product, with quantity, price break, date, alternate and lifecycle status.

Two BLE devices remembering their keys so they can reconnect securely without pairing again.

The device that connects a Thread mesh to the home's Wi-Fi or Ethernet network.

The part of the Rust compiler that proves every reference is valid and no value has two writers at once.

A crowd of hijacked devices that all take orders from one controller.

A small marker in memory that survives a crash and says what the program was doing.

A device with no program it can boot and no way to fix it remotely.

The last address of a subnet, with all host bits 1; a packet sent there goes to every device on the subnet.

The server in the middle that receives every published message and hands copies to subscribers.

Running one CI job once per value of a parameter, such as each board, in parallel.

A +suffix on a version, like 1.4.0+20261022, ignored when comparing versions.

A record, ideally signed, of how an artefact was built: commit, toolchain, workflow, runner.

The central system that runs a building's heating, ventilation and lighting.

Data delivered as one continuous run of bytes, with no message boundaries kept.

A sensor's readings slowly moving away from the truth while each still looks plausible.

The written plan for one capstone, made before any code: requirements in three versions, architecture, contracts, threat model, BOM, milestones, tests, demo, review and rubric.

A network that sends every request to a login page until you sign in.

Losing nearly every significant digit by subtracting two large, nearly equal floating-point numbers.

A binary format that holds the same kinds of data as JSON in fewer bytes.

The BLE device that scans and starts connections, usually a phone or gateway.

A signed document binding a name to a public key, so others can check that key really belongs to that name.

The party whose signature on a certificate others agree to trust.

Leaf, then intermediate, then a root the client already trusts, each signed by the next.

A PKCS #10 request holding a name and public key, signed with the matching private key.

Each boot stage verifies the next stage's signature before running it, starting from the root of trust.

The slice of the radio band a Wi-Fi network uses; neighbours on the same channel share airtime.

One BLE data item, like the temperature, that can be read, written or subscribed to.

A credential shared by a batch, allowed only to request a device's own identity at first connection.

How evenly the examples are spread across the classes.

A connection where the broker forgets everything about the client when it disconnects.

Any program or device that connects to the broker to publish or subscribe.

A certificate the device presents so the broker can check the device's identity.

The name a client gives the broker so the broker can tell connections apart and find its saved session.

Running a sensor beside a trusted reference instrument to work out its correction.

A small web protocol for tiny devices, with GET, PUT and POST like HTTP but carried over UDP.

A message telling a device to do something.

One fault that knocks out several protection layers at once.

The phone or browser app that is a BLE device's user interface.

Undoing a command by sending a new command that reverses it, rather than pretending the first never happened.

A CoAP message the receiver must acknowledge, which the sender repeats until it does.

A table counting, for each true class, which class the model said.

A sender slowing down when the network itself is overloaded.

How often two connected BLE devices wake up to exchange data.

A table of what each pin of a connector carries, and which side it is drawn from.

A real, informed yes, with optional data off until switched on.

A packaged program with everything it needs, run isolated from the rest of the machine.

Building and testing every change automatically as soon as it's pushed.

Keeping a machine's fast control loops local and sending only goals and status over the network.

A label a command carries so its reply can be matched back to it.

A device that keeps rebooting for a bad reason (watchdog, panic, brownout).

A message sent at boot describing why the device last restarted.

What one login is allowed to do -- as little as its holder needs.

Building a program on one kind of computer to run on another, such as on a laptop for an ESP32.

Wi-Fi's listen-before-talk rule: wait until the air is quiet, then wait a random extra moment before sending.

The EU law setting security duties for products with digital elements (as of 2026-10, main duties from December 2027).

A system whose software reads and drives physical things: heaters, valves, locks.

An OWASP standard format for SBOMs.

The inputs in the field slowly moving away from the training data.

Collect only what the purpose needs, at the resolution it needs.

Computing on the device so that much less data has to leave it, such as a few features instead of every sample.

A picture of a system as outsiders, programs, storage and arrows of data.

One self-contained message sent on its own, like a postcard.

A drive's timer that stops the motor when no fresh command arrives in time.

A short document recording one significant design decision, its context and consequences.

Retiring a device for good -- revoking its credentials and removing its data from active use.

The router a device sends a packet to whenever the destination isn't on its own subnet.

The settings the app wants that the device hasn't confirmed yet.

Numbered demo steps, each naming a requirement, an action and the expected result.

Refuse everything, then allow only what's listed.

Design choices that make a board cheap and reliable to build.

Design choices that let every board be checked quickly in the factory.

A meeting where people who didn't design a system check it against its requirements before costly steps.

What the app wants the device's settings to be.

How long it takes a device to notice that its connection is gone.

A ready-made .NET class that knows how to talk to one sensor or chip.

What a device is (its ID and the secret that proves it), as opposed to where it currently is on the network.

The back end's list of every device it knows, with its identity and status.

A copy of a device's state kept by the back end, so apps can read or change it even while the device is offline.

A program that pretends to be one or many devices, sending realistic messages, so you can test without hardware.

How a device asks the network for an IP address, a gateway and DNS servers when it joins.

An IP address a router lends a device for a limited time.

Made with a private key, checked by anyone with the public key.

A unit inside some ESP32s that signs with a key the CPU never sees.

A buffer network between the plant and the office that both can reach but neither can cross.

The internet's phone book: it turns a name like broker.example.com into an IP address.

A database that stores each record as a JSON-like document instead of rows in fixed columns.

Tricking a device into installing an older, genuinely signed release that has a known hole.

Replacing many detailed readings with fewer summary ones, such as hourly averages.

The rule for which message to throw away when the offline queue is full.

A legal cap on how much of the time a device may transmit in some radio bands.

Processing data on or near the device instead of sending it all to a distant server.

One-time-programmable bits inside the ESP32; once burned they can't be changed, and key blocks can be made unreadable.

A Rust framework that runs many async tasks on a microcontroller without an operating system.

A shared set of Rust traits, such as "an output pin" or "an I2C bus", that drivers can be written against.

EU harmonised standards for the RED's security requirements on connected radio equipment.

Wrapping data in one header after another as it goes down the layers, like envelopes inside envelopes.

Testing a device in the heat, cold, damp and condensation it will live in.

A maker's announcement that a part will stop being made.

One full pass over the training set.

Who is called for which problem, how fast, and how to reach them out of hours.

The Rust hardware library for Espressif chips, whose version 1.0 promises a stable core API.

Espressif's MQTT client library, built into the ESP32's Arduino core.

Espressif's way for ESP32s to send short messages straight to each other, without a Wi-Fi network.

The Rust crate that drives an ESP32's Wi-Fi and Bluetooth radio.

Espressif's tool that reads (summary) and burns eFuses; --virt simulates a chip.

Wired networking over a cable.

The European baseline for consumer IoT, starting with no universal default passwords.

Designing a system so parts react to events as they happen instead of asking each other for updates.

Each message has its effect exactly one time, even if it was delivered twice.

The part of an async framework that decides which waiting task to run next.

Add the new setting first and remove the old one only in a later release.

Being able to say why a system made a decision, in terms the person acting on it understands.

Waiting longer after each failed retry, usually doubling the wait each time.

Wiping a device's saved settings, such as Wi-Fi credentials, so it starts like new.

One particular way a part of a system can break.

Times a keyword device fires when the word wasn't said, counted per hour.

An alert raised when nothing is actually wrong.

How often a detector fires when nothing happened, per decision.

Times the keyword was said and missed.

Disturbing a chip's voltage, clock or EM field at a chosen instant so a check misbehaves.

One number computed from a window of readings that keeps something the window says.

The grid of numbers a model reads, such as 49 frames × 40 bands for one second of audio.

A short, fixed-length list of numbers that sums up one window of sensor readings.

The way code in one language calls functions written in another, such as Rust calling C.

A filter whose output is a weighted sum of the last few inputs.

The compiled program as one binary file that gets written to flash.

A whole number with an agreed scale, so that it can stand for a fraction without floating-point hardware.

Flash contents stored AES-XTS-encrypted under a per-chip key in a read-protected eFuse block, decrypted transparently by hardware.

All the devices a team runs, managed together rather than one by one.

The receiver telling the sender how much it can accept, so it isn't overwhelmed.

A weakly protected device an attacker gets into first, to reach something better.

A tool that rewrites code into one fixed layout without changing its meaning.

The unit a local network link (Ethernet or Wi-Fi) actually sends, carrying a packet inside.

A requirement saying what the system does in response to an input or event.

The part of safety that depends on a system working correctly when needed.

A box that sits between devices and the rest of the system, translating, buffering or filtering their messages.

How a connected BLE device organizes its data into services and characteristics.

The EU's personal-data law, one example of the rules telemetry must follow.

A low-risk product making only lifestyle claims, such as activity or sleep, not disease claims.

.NET's ready-made frame for a long-running program, handling start-up, configuration, logging and shutdown.

An invisible boundary on a map that turns positions into arrive and leave events.

Satellite positioning, the general name for GPS, Galileo, GLONASS and BeiDou.

A cheap way to compute one DFT bin, one multiply per sample.

A complete example message, owned by the contract, that every implementation's tests must agree with.

A library that turns raw registers into easy, safe functions like "set this pin high".

A rule written in advance that stops a rollout when too many devices fail.

A tamper-resistant device that keeps keys and signs with them without ever exporting them.

Running the real firmware on a real board while a computer controls and checks everything around it.

Turns any data into a short fingerprint; no key, so anyone can recompute it.

The control information at the front of a packet: addresses, lengths, flags.

RAM deliberately left unused for stacks, the heap and later features.

The checks, with a deadline, a new image must pass before it is marked valid.

A small message a device sends on a schedule just to say it is still alive.

Raw bytes printed as two-digit hexadecimal numbers, usually 16 to a line with the offset on the left.

Two devices that can both reach the access point but can't hear each other, so their transmissions collide.

How long a rule's condition must stay true before the rule acts, so a brief blip doesn't trigger it.

How many new samples arrive between the start of one window and the next.

The request-and-response protocol of the web: a client asks for something, a server answers.

HTTP sent inside an encrypted, authenticated TLS connection.

A unique label a client sends with a request so the server can recognise a retry and not act twice.

Safe to do twice: doing it again changes nothing.

The general international standard for functional safety of electronic and software systems.

The standard for how medical device software is developed and maintained.

The family of standards for securing industrial automation and control systems.

Running a trained model on new input to get an answer.

Taking messages off the broker, checking them and writing them into storage.

Storing a real number r as an 8-bit code q with r = scale × (q − zero point).

A test that runs several real parts together, such as the service with a real broker and database.

What the maker says a product is for, which decides whether it is a medical device.

The written agreement for one connection between two parts of a system.

An embedded device that talks to other devices or services over a network.

The number that identifies a device on a network so packets can reach it.

The newer internet address format: 128-bit addresses written in hexadecimal groups like fe80::1.

The functional-safety standard for road vehicles.

A random amount added to or taken from a retry wait so many devices don't retry at the same instant.

A log of changes written before applying them, replayed after a crash.

A text format for data made of objects (named fields in braces), arrays (lists in brackets), strings, numbers, true, false and null.

A signed token carrying who the user is and when the token expires, which a server can check without a database lookup.

The longest a client promises to stay silent; it sends a ping if it has nothing else to say.

Two machines invent a shared secret while everyone listens, without listeners learning it.

A station that writes factory-made keys into devices and must never keep them.

Each side's half of the fresh shared secret, sent in the TLS hellos.

A deliberately slow, salted way of turning a password into a stored value, so stolen values are hard to crack.

A free, open-source tool for drawing schematics and laying out circuit boards.

A building-control bus and protocol, widespread in European homes and buildings.

The class you assert for one training example, such as "tap".

The share of examples carrying the wrong label.

A message a client leaves with the broker in advance, which the broker publishes for it if the client disappears without saying goodbye.

The final date a maker takes orders for a part it is discontinuing.

How long a message takes to get from sender to receiver.

How long one run of the model takes on the board.

When the test set shares information with the training set, so the test score is too good.

Giving each device only the access its job needs, and nothing more.

Whether a part is active, not recommended for new designs, end of life, or obsolete.

An address a device gives itself that only works on its own local link (IPv6 addresses starting fe80::).

The map that tells the linker where flash and RAM are on the chip and where each part of the program goes.

A tool that reads code and reports patterns that are often bugs.

Google's converter and file format for small, fast models; called TensorFlow Lite until 2024.

A site carrying on with its essential jobs when it can't reach the cloud.

A file listing the exact version of every package a build uses, direct and transitive.

A long-range, very low-data-rate radio that can reach kilometres on a small battery.

The network system on top of LoRa: devices send to gateways, which pass messages to a network server.

Cellular service made for devices: low power, moderate speed, works while moving.

A device's hardware address on the local network, six bytes like 24:6f:28:aa:bb:cc.

After a person switches something, the automation rules leave it alone for a set time, here 30 minutes.

A valve upstream of all the zone valves that can stop the whole irrigation supply.

A smart-home standard so devices from different brands work with each other and with every big home app.

The TLS and cryptography library ESP-IDF ships for the ESP32.

How devices on a local network find each other by name (like greenhouse.local) without a DNS server.

A product, software included, that its maker intends for diagnosing, monitoring or treating disease.

A pitch scale with narrow bands at low frequencies and wide ones at high, like human hearing.

A program that never reads or writes memory it doesn't own at that moment.

A network where devices relay each other's messages, so it can reach farther than any one radio.

A fingerprint made with a shared secret, proving the message came from a key holder.

The written agreement about what a message contains, so sender and receiver agree without reading each other's code.

An MQTT 5 setting that tells the broker to throw a message away if it hasn't been delivered in time.

A number or string that uniquely names one message so a receiver can spot a repeat.

The verb in an HTTP request, like GET (read) or POST (create).

A compact description of each audio frame made from its mel-band energies.

A numbered change to a database's tables, applied once when the new version of the program starts.

A thousandth of the acceleration due to gravity; 1 g is 1000 mg.

An ASP.NET Core endpoint written as one route and one function, without a controller class.

A real fault that raises no alert.

What you do to stop a threat, or make it cost more than it's worth.

A Wi-Fi power-saving mode where the radio sleeps between beacons while staying connected.

One repository holding every part of a system.

A clock that only counts up from boot and never jumps, like millis().

A free, open-source MQTT broker you can run on your own computer.

A small publish/subscribe messaging protocol built for devices on unreliable networks.

The largest packet a link carries in one piece; BLE has its own, smaller one.

The # at the end of a topic filter, standing for that level and everything below it.

TLS in which both sides show certificates, so each checks the other.

The trick a home router uses so many devices with private addresses can share one public address.

Cellular service for small, rare messages from devices that stay put.

A label naming a net by what it carries, such as I2C_SDA or FAN_PWM.

The first address of a subnet, with all host bits 0; it names the subnet itself.

Deliberately adding loss, delay or outages to a network so you can test how software copes.

Any event that stops a device's messages from getting through: the router reboots, the signal fades, the broker restarts.

Splitting one network into several with rules between them.

NIST's six security capabilities every IoT device should have.

A Rust program that uses only the core library, because there is no operating system underneath.

A requirement saying how well the system works, such as battery life, latency, uptime, range or cost.

Being able to prove to someone else who did something.

The BLE device pushing a new value to the connected phone without being asked.

One-time costs of making a product at all, spread over the units made.

A part still made, but which its maker advises against for new designs.

How a device asks a time server on the network what time it is.

ESP-IDF scrambling the stored-settings partition with a key the chip protects.

Being able to tell what a device or service is doing from the data it sends out.

A CoAP option that asks a server to keep sending a resource's new value whenever it changes.

The fixed-size buffer where a device keeps readings it couldn't send yet.

The list of operator implementations TFLM may use for a model.

The networks and computers that run physical machines and processes.

Letting an update through only if nobody else changed the document since you read it.

The small record that tells the bootloader which slot to start and what state it is in.

Replacing a device's firmware through its own network connection.

When a model memorises its training examples and gets worse on new ones.

OWASP's testable IoT security checklist, in three levels.

A small chunk of data sent across a network, with a header saying where it's going.

A recording of the packets that crossed a network interface, so you can inspect them later.

The share of packets that never arrive.

Two BLE devices agreeing on encryption keys, sometimes with a PIN or a number to confirm.

The function a no_std Rust program must provide to decide what happens when it panics.

The numbers inside a network that training adjusts.

The highest reading in a window minus the lowest.

Giving each output channel's weights their own scale.

The BLE device that advertises and waits to be connected to, usually the sensor.

A crate generated from a chip's register description, giving typed access to every register.

A connection where the broker remembers the client's subscriptions and saves QoS 1 and 2 messages for it while it is offline.

Information about a person who can be identified, including what their readings reveal.

Data sent without encryption, readable by anyone on the path.

A fault caused on purpose during a demo or test to show the system copes.

The rugged industrial computer that runs a machine.

Power over Ethernet: one cable carries both the network and the device's power.

Asking a server again and again whether anything has changed.

A number from 0 to 65535 that picks which program on a computer gets a message.

A radio module its maker has already had tested and approved.

A test version like 1.4.0-rc.1, which counts as older than 1.4.0.

Repairing a machine when its condition shows wear, before it fails.

The /24 after an address: how many leading bits name the network.

Addresses (10.x, 172.16-31.x, 192.168.x) that home and office networks use inside, which the internet never routes.

A checklist review, with evidence for every line, before a product ships.

A web page that can be installed on a phone's home screen and work somewhat like an app.

The CSR's signature, showing the sender holds the private key for the public key in it.

The agreed rules for an exchange between two parties: what to send, in what order, and what each message means.

A compact binary format whose messages are described by a schema both sides share.

A gateway turning one protocol into another, such as BLE readings into MQTT messages.

The labels that travel with data to say where it came from.

Getting the settings a device needs (like Wi-Fi credentials) onto it after it's built, without editing its code.

The factory computer that forwards CSRs for signing, records devices and audits every attempt.

The UK's security regime for consumer connectable products, in force since April 2024.

A wired-network clock protocol much more precise than NTP.

The acknowledgement a receiver sends back for a QoS 1 message.

A messaging pattern where senders publish to a topic and anyone subscribed to it gets a copy, without the two knowing each other.

The standard layered picture of an industrial network, from machines up to the enterprise.

A message an app's server sends to a phone through Apple's or Google's push service.

The name of a fixed-point number's scale, such as Q15 (value × 32 768) or Q8.8 (value × 256).

MQTT's delivery promise for a message: 0 (at most once), 1 (at least once) or 2 (exactly once between two hops).

A label on each reading (good, suspect, bad, missing) that says whether to trust it.

Storing a model's numbers as small integers instead of floats.

The approval a product with a radio transmitter needs before it can be sold in a market.

A cap on how many requests one caller may make in a period.

The first document a developer reads, saying how to build, test and run each part.

A number an MQTT 5 broker or client sends back to say exactly why something succeeded or failed.

Of the real examples of a class, the fraction the model found.

Real readings saved from a real sensor and replayed through the code in a test.

A standard layout of a system's parts that you adapt instead of designing from nothing.

A part's label on a schematic and BOM, such as U1 or R4.

What a release changed, for whoever installs and supports it.

Sending selected log lines from devices to the back end, with levels and rate limits.

What the device says its settings actually are.

Realistic inputs the converter runs through a model to find each tensor's range.

A build that gives byte-for-byte the same output from the same source and toolchain.

Making publish/subscribe behave like ask-and-answer by publishing a request and waiting for a reply on another topic.

A style of web API where each thing has its own URL and you use HTTP methods to read and change it.

A message the broker keeps and hands to anyone who subscribes later, so they get the last known value at once.

The rule for how long each kind of data is kept before it is deleted.

Sending data again because no acknowledgement came back in time.

Withdrawing a device's credential before it expires, so the next connection with it is refused.

The square root of the average squared deviation, a fair measure of how strongly something is shaking.

Giving people permissions through roles, such as viewer or operator, instead of one by one.

Going back to the previous working firmware when a new one fails.

The part trusted without a check because nothing runs before it and it can't be changed: ROM plus burned eFuses.

How long a message takes to get there and for the reply to come back.

A device that passes packets between networks.

How strong the radio signal is, in dBm; closer to 0 is stronger.

A scoring table: one row per criterion, with levels (missing, partial, met, exceeded) that describe what an observer can see.

Zero events in n trials suggests the true rate is below about 3/n.

A service that watches incoming messages and runs an action when one matches a rule.

Instructions for the engineer on call, one entry per alert or common fault.

The machine or container that runs a CI job's steps.

A short name like linux-arm64 that tells .NET which operating system and processor to build an app for.

One protective job, like cutting a heater above a temperature.

How reliable a safety function must be, from SIL 1 to SIL 4 in IEC 61508.

Describes a system whose failure could injure or kill people or cause serious harm.

Random bytes stored with each password hash so two equal passwords never hash the same.

A value beyond the quantized range stuck at the largest or smallest code.

A machine-readable list of every component in a piece of software, with versions.

The real-number size of one int8 step.

Checking that incoming data has the fields, types and ranges the contract promises before using it.

A number in a message saying which version of its contract it follows.

A second part, ideally from another maker, that can replace one on the BOM.

The chip runs only code signed by a key whose digest is burned into eFuse (Secure Boot v2 on ESP32).

ESP32 download mode limited to a few commands, none of which reads flash or memory.

A separate small chip that makes and keeps a device's private key and signs with it, so the key never leaves.

Giving a device its own key and certificate without the private key being anywhere it shouldn't.

A published list of what every device should do, whatever its design.

Publishing a .NET app together with its runtime so the target machine needn't have .NET installed.

A CI service's runner program installed on a computer you own.

A number on each piece of data so the receiver can put it in order and spot repeats.

A way for a server to keep sending updates to a web page over one long HTTP response.

A group of related BLE data items, like an environmental sensing service.

A numbered step that converts stored settings to the next version's format.

Running a new model beside the current one, logging its decisions without acting on them.

A subscription several clients share, so each message goes to just one of them.

Recovering a key from power, emissions or timing that depend on it.

Named people with authority recording that a release may ship.

A small computer on one board, like a Raspberry Pi, that runs a full operating system.

The + in a topic filter, standing for exactly one level of the topic.

A value of which only one can ever exist, such as the one handle to a chip's GPIO8 pin.

How an IPv6 device builds its own address from the network prefix a router announces.

Running a device for days under realistic load while logging what drifts, such as free memory.

The program's end of a network conversation: an address plus a port.

Wi-Fi mode where the device makes its own small network that a phone can join.

Turns a list of scores into probabilities that add up to 1.

A Linux Foundation standard format for SBOMs, also ISO/IEC 5962.

How much of one frequency a window holds, from the Fourier transform.

A frequency between two bins spreading its energy into both, so neither shows its full size.

A picture of how loud each frequency is over time.

A LoRa setting that trades speed for range: higher means slower but farther.

The name of a Wi-Fi network.

Sending a change to a few devices first and only to the rest if those stay healthy.

A published specification, kept by a standards body, that many vendors build to.

The current condition of a device, like whether the fan is on, as opposed to a stream of readings.

Finding likely bugs by reading code without running it.

Wi-Fi mode where the device joins an existing network as a client.

The three-digit number at the start of an HTTP response saying how it went, like 200 OK or 404 Not Found.

Keeping messages on the device while offline and sending them once the connection is back.

Six kinds of threat: Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege.

The list of names a certificate is valid for; the hostname check uses it.

A group of addresses that share the same first part, so they are on the same local network.

The same thing as a prefix length, written as an address like 255.255.255.0.

A package of diagnostic state a device assembles on request, with secrets removed.

Passing responsibility for a running system to the team that will support it.

How long a product will get security fixes, stated in advance.

A program Linux starts at boot and restarts if it crashes.

Tags say which device a reading came from; fields hold the measured numbers.

One of the weights a FIR filter multiplies its recent inputs by.

A name like riscv32imac-unknown-none-elf that tells the compiler which processor and system to build for.

The protocol that gives two programs a reliable, ordered stream of bytes over an unreliable network.

Measurements a device sends home, like temperature readings.

One customer whose devices and data share a system with other customers' but must stay separate.

The one block of RAM in which TFLM keeps every tensor while a model runs.

A C++ interpreter that runs .tflite models on microcontrollers in one fixed block of RAM.

Anything that stands in for a real dependency during a test: a stub, a fake or a mock.

A jig, often spring pins on test pads, that powers and tests each board on the line.

A written list of a release's tests, each with its conditions and a measurable pass criterion.

A pad placed so a spring-loaded pin can touch a rail or signal during testing.

Many cheap fast tests at the bottom, a few slow expensive ones at the top.

Examples kept back and used once, at the end, for the reported result.

A low-power mesh network for smart-home devices that speaks IPv6.

A written answer to: what are we building, what can go wrong, what will we do, did we do enough?

The SYN, SYN-ACK, ACK exchange that opens a TCP connection.

How much data per second actually gets through.

Thousands of devices all reconnecting at the same moment and overwhelming the server.

A list of measurements, each stamped with the time it was taken.

How long a satellite receiver takes to find its first position after switching on.

A slice of time, such as one hour, over which readings are grouped and summarised.

A database built for storing and querying readings ordered by time.

Running trained machine-learning models on microcontrollers, with kilobytes of RAM and milliwatts of power.

The protocol that encrypts a connection and lets each side check who the other is.

A rate limit that lets a caller spend saved-up tokens in a burst, then only as fast as tokens refill.

The slash-separated name a message is published to, like home/kitchen/temp.

The pattern a subscriber asks for; it can contain wildcards to match many topics.

The planned layout of all the topics a system uses.

A write cut off by a power loss, leaving neither the old nor the new data.

Adjusting a model's parameters until its outputs match labelled examples.

The examples a model's parameters are fitted to.

A rule on a generic type saying what it must be able to do, like "P must be an output pin".

A new image's first run, on probation until it marks itself valid.

A line around things that trust each other equally; arrows crossing it need the most care.

The root certificates a device trusts, installed in advance.

A simple way to send a single message to a port, with no setup and no promise it arrives.

A signed description of a release: version, chip, size, hash and where to get it.

The FCC's voluntary security label for consumer wireless IoT products.

A name-value label an MQTT 5 message can carry alongside its payload.

The standard way to store text as bytes: plain English letters take one byte each, other characters take two to four.

A 128-bit ID that names a BLE service or characteristic.

Held-out examples used to make choices during training, such as when to stop.

Being tied to one provider because moving away would cost too much.

A dependency requirement that allows many versions, such as ^7.4.

A separate network sharing the same switches and Wi-Fi, kept apart by tags.

The thinnest version of a system that still runs end to end through every box, built as the first milestone.

The real date and time, which a device only knows after asking the network.

A browser feature (in some browsers) that lets a web page talk to a nearby BLE device after the user picks it.

Sending a notification to a web page's background worker through the browser's push service.

A connection that starts as HTTP and then stays open so both sides can send messages any time.

A way to keep a running mean and variance, one value at a time, without big sums that lose precision.

A fixed run of consecutive samples treated as one unit, such as one second of readings.

One row per wire in a harness, with both ends, the net, colour, gauge and current.

The common Wi-Fi security standard that encrypts traffic using a shared password.

The newer Wi-Fi security standard, which resists password guessing even if someone records the traffic.

The processor design in the ESP32-S3 and original ESP32, which stock Rust doesn't support yet.

How many standard deviations a value is above or below the mean.

A point where a signal crosses its average; counting them estimates how fast it oscillates.

The int8 code that stands for exactly 0.

An older low-power mesh standard for smart-home and building devices.

Groups of equipment with the same trust, and the controlled paths between them.