Skip to content

Glossary

This glossary lists every technical term introduced on this site, in alphabetical order. Each term links to the page where it is first explained, and each page lists its new terms in a Terminology callout at the top.

0–9 · A · B · C · D · E · F · G · H · I · K · L · M · N · O · P · Q · R · S · T · U · V · W

0–9

  • 24-hour time – a way of telling the time where hours go from 0 to 23 instead of using am and pm. (Real Time Clock)

A

  • accelerometer – a sensor that measures movement and tilt in three directions and can recognise gestures such as shaking. (Accelerometer)
  • adapter – a board that the micro:bit plugs into so PiicoDev modules can be connected to it. (Using PiicoDev)
  • address switch – a small switch (marked ASW) on some PiicoDev modules that lets us connect two of the same module at once. (Using PiicoDev)
  • air pressure – the weight of the air pushing down on us, which drops as we go higher. (Atmospheric Sensor)
  • alligator clip – a spring-loaded metal clip on a wire used to make quick connections without soldering. (Glowbit Rainbow)
  • altitude – the height above sea level, which the Atmospheric Sensor works out from air pressure. (Atmospheric Sensor)
  • ambient light – the general light in the surroundings. (Colour Sensor)
  • axis – an imaginary line, called x, y or z, along which movement is measured. (Accelerometer)

B

  • background – running code on a schedule while the main loop keeps doing something else. (microbit Module)
  • Boolean – a value that can only be True or False. (Display)
  • breakpoint – a marker on a line of code where the debugger pauses the program so we can check the variables. (Debugging with Thonny)
  • bug – an unexpected behaviour in a program caused by a mistake in the code. (Debugging with Thonny)

C

  • calibration – adjusting a sensor so its readings are accurate, such as tilting the micro:bit until every LED is lit. (Compass)
  • capacitive touch – a way of sensing touch by detecting the tiny electrical charge in our finger, the same idea used by phone screens. (Touch)
  • channel – one of the numbered connection points on the Servo Driver where a servo plugs in. (Servo Driver)
  • colour temperature – a measure, in kelvin, of how warm (yellowish) or cool (bluish) white light looks. (Colour Sensor)
  • colour wheel – a circle of colours that lets us describe each colour by its position or angle around it. (Colour Sensor)
  • comment – a note in our code, starting with #, that explains the code and is ignored when the program runs. (Creating Your Program)
  • concatenation – joining strings together end to end with +. (Debugging with Thonny)
  • continuous rotation servo – a servo that spins like a wheel at a speed from -1 (full speed backwards) to 1 (full speed forwards). (Servo Driver)
  • contrast – how bright the screen is compared to its dark parts, which sets how easy it is to see. (OLED Display)
  • coordinates – a pair of numbers (x, y) that give the position of a pixel, with x across and y down. (Display)

D

  • data pin – the pin that carries signals from the micro:bit to tell a device what to do. (Glowbit Rainbow)
  • debugger – a tool that helps us hunt down bugs by running code one step at a time and showing variable values. (Debugging with Thonny)
  • debugging – the process of finding and removing bugs from a program. (Debugging with Thonny)
  • define – to create a new function by giving it a name and the code it runs, using def. (microbit Module)
  • device driver – a file of code that gives our program the commands to control one type of module. (Using PiicoDev)
  • dictionary – a collection that stores values with names, called keys, so we can look each value up by its name. (Colour Sensor)
  • directory – another name for a folder that holds files on a computer or micro:bit. (Your First Program)
  • distance sensor – a sensor that measures how far away an object is. (Distance Sensor)
  • documentation – the official guide written by the people who made a code library, explaining every method and its parameters. (Display)
  • duration – how long a note or tone lasts. (Sound)

E

  • embedded programming – writing programs that run on microcontrollers built into devices. (Setting up Thonny)
  • endless loop – a loop, started with while True:, that repeats its code forever until the program is stopped. (Your First Program)

F

  • float – a number with a decimal point, such as 3.14. (Display)
  • for loop – a loop that repeats its code once for each item in a list or other collection. (Debugging with Thonny)
  • frequency – how many times a sound wave vibrates each second, which sets how high or low a tone sounds. (Sound)
  • function – a named block of code that does a job and can be run whenever we call its name. (microbit Module)

G

  • gesture – a movement the accelerometer can recognise, such as shaking, tilting or turning face up. (Accelerometer)
  • GND – ground, the connection that completes an electrical circuit back to the negative side of the power. (Glowbit Rainbow)
  • group – a number from 0 to 255 that sets which micro:bits can hear each other's radio messages. (Radio)

H

  • heading – the direction the top of the micro:bit is pointing, measured in degrees from 0 to 359. (Compass)
  • hertz – the unit of frequency (Hz), meaning one vibration per second. (Sound)
  • horn – the plastic arm that fits onto a servo's hub. (Servo Driver)
  • HSV – a way of describing a colour by its hue, saturation and value. (Colour Sensor)
  • hue – which colour something is, given as an angle on the colour wheel, such as red 0, green 120 and blue 240. (Colour Sensor)
  • humidity – the amount of water vapour in the air, measured as a percentage. (Atmospheric Sensor)

I

  • ID switch – a small switch on the back of a PiicoDev module that gives it a different ID so we can use more than one at once. (Potentiometers)
  • IDE – an Integrated Development Environment, which is an app for writing, running and fixing code. (Setting up Thonny)
  • if statement – code that makes a decision by running some lines only when a condition is True. (Creating Your Program)
  • import – a line that brings code someone else has already written into our program so we can use it. (Creating Your Program)
  • indentation – spaces at the start of a line that show which code belongs inside a loop or if statement. (Creating Your Program)
  • input – information our program reads, such as a button press, a sensor reading or a radio message. (Creating Your Program)
  • integer – a whole number with no decimal point, written int in Python. (Display)
  • interpreter – the program that reads our code and runs it, such as MicroPython on the micro:bit or Python 3 on the computer. (Setting up Thonny)

K

  • key – the name used to store and look up a value in a dictionary, such as "red" in data["red"]. (Colour Sensor)

L

  • laser – a narrow, focused beam of light; the Distance Sensor uses an invisible one to measure distance. (Distance Sensor)
  • LED – a light-emitting diode, which is a small electronic light; the micro:bit display is a 5 × 5 grid of them. (Display)
  • library – a collection of ready-made code, such as the microbit library, that we import to use in our programs. (Your First Program)
  • light sensor – a sensor that measures how much light is shining on it; on the micro:bit, the display LEDs do this job. (Light Sensor)
  • list – a collection of values, written in square brackets, that is stored in order under one name. (Sound)
  • local variable – a variable that only the current function can see. (Debugging with Thonny)
  • logic error – a mistake where a valid program runs but doesn't do what the programmer intended. (Debugging with Thonny)

M

  • magnetic field – the invisible area of magnetic force around a magnet or the Earth. (Compass)
  • magnetometer – a sensor that measures magnetic fields, used by the micro:bit as a compass. (Compass)
  • main loop – the part of a program, inside while True:, that repeats forever to read inputs, make decisions and control outputs. (Creating Your Program)
  • method – a command that belongs to an object, such as the display, and is written after a dot. (Display)
  • micro servo – a small servo that turns to an angle from 0° to 180° and holds it there. (Servo Driver)
  • micro:bit – a small, pocket-sized educational computer with buttons, a display and sensors that we can program. (Setting up Thonny)
  • microcontroller – a tiny computer chip used to control devices such as robots, sensors and household appliances. (Setting up Thonny)
  • microphone – an input device that detects sound and measures how loud it is. (Sound)
  • MicroPython – a version of the Python programming language designed to run on microcontrollers. (Setting up Thonny)
  • milli-g – the unit for accelerometer readings, where about 1024 milli-g equals the pull of gravity. (Accelerometer)
  • millisecond – one thousandth of a second, so 1000 milliseconds make 1 second. (Your First Program)
  • module – a collection of code, such as microbit, music or radio, that we can import into our program. (microbit Module)

N

  • nanotesla – a very small unit for measuring the strength of a magnetic field. (Compass)
  • NeoPixel – a type of full-colour LED that can be joined in strips and controlled one at a time from a single data pin. (Glowbit Rainbow)
  • None – a special Python value meaning nothing, such as when no radio message has arrived. (Radio)

O

  • octave – a range of musical notes, numbered from 0 (very low) to 8 (very high), where octave 4 contains middle C. (Sound)
  • OLED – an organic light-emitting diode screen, which is a display made of tiny pixels that each give off their own light. (OLED Display)
  • output – the result our program shows or does, such as using the display, sounds, LEDs or motors. (Creating Your Program)

P

  • parameter – a value we give to a method inside its brackets to control what it does. (Display)
  • pascal – the unit for measuring pressure (Pa); 100 pascals make 1 hectopascal (hPa). (Atmospheric Sensor)
  • PBM – a portable bitmap, which is a simple image file made only of black and white pixels. (OLED Display)
  • phoneme – a single sound that makes up part of a spoken word, used to tell the micro:bit exactly how to say it. (Sound)
  • PiicoDev – a range of plug-and-play sensors and output modules made by Core Electronics that connect with the same cable, with no soldering needed. (Using PiicoDev)
  • pin – a metal connection point on the micro:bit, such as pins 0, 1 and 2, that can be used for inputs and outputs. (Touch)
  • pitch – how high or low a sound or voice is. (Sound)
  • pixel – a single dot of light on a display that can be turned on, off or set to a brightness. (Display)
  • potentiometer – an input, also called a pot, that gives a value which changes smoothly as we turn a knob or move a slider. (Potentiometers)
  • PRIMM – a five-step way of learning to code: Predict, Run, Investigate, Modify and Make. (Your First Program)
  • process – the step where our program works out what to do with its inputs, using calculations and decisions. (Creating Your Program)
  • processor – the main chip that runs programs on the micro:bit; its temperature sensor is built inside it. (Temperature)
  • property – a value that belongs to an object, such as pot.value, that we read or set without brackets. (Potentiometers)
  • push button – a button that detects when it is pressed and held down, such as buttons A and B on the micro:bit. (Buttons)

Q

  • queue – a line of waiting items where the oldest one is dealt with first, like received radio messages. (Radio)

R

  • radio – a way of sending and receiving messages without wires, using invisible radio waves. (Radio)
  • range – the lowest and highest values a reading can give. (Potentiometers)
  • raw value – a sensor reading before it has been scaled into a more useful range. (Potentiometers)
  • real time clock – a module that keeps track of the date and time, even while the micro:bit is turned off. (Real Time Clock)
  • return value – the information a method gives back to our program after it runs. (Display)
  • RGB – a way of describing a colour by how much red, green and blue light it contains. (Colour Sensor)
  • RGB LED – an LED that mixes red, green and blue light so it can show any colour. (3x RGB LED)
  • run-time error – a mistake that makes the program crash while it is running. (Debugging with Thonny)

S

  • saturation – how intense a colour is, from bright and strong to greyish. (Colour Sensor)
  • scope – the part of a program where a variable can be seen and used. (Debugging with Thonny)
  • servo driver – a module that sends the signals to control up to four servo motors. (Servo Driver)
  • servo motor – a motor that can be controlled to turn to an exact angle or spin at a set speed. (Servo Driver)
  • setup – the part of a program that runs once when it starts, for creating devices and giving variables their starting values. (Creating Your Program)
  • Shell – the part of the Thonny window that shows messages and printed output from our program. (Setting up Thonny)
  • speaker – an output device that turns electrical signals into sound. (Sound)
  • speech synthesiser – software that creates spoken words from text, which makes the micro:bit's voice sound robotic. (Sound)
  • stack – the list of functions and modules that are currently running, showing which one called which. (Debugging with Thonny)
  • string – a piece of text made of characters, written inside quotation marks. (Display)
  • syntax error – a mistake in how the code is written, such as a missing bracket, that stops Python from running it. (Debugging with Thonny)

T

  • temperature sensor – a sensor that measures how hot or cold it is, in degrees Celsius. (Temperature)
  • Thonny – a beginner-friendly IDE for writing and running Python and MicroPython programs. (Setting up Thonny)
  • timestamp – the date and time written as one string, such as YYYY-MM-DD HH:MM:SS. (Real Time Clock)
  • tuple – a collection of values written in round brackets, like a list, but whose values can't be changed after it is created. (Accelerometer)

U

  • Unix time – the number of seconds that have passed since 1 January 1970. (Real Time Clock)
  • unpacking – storing each value from a tuple or list into its own variable in one line, such as x, y, z = accelerometer.get_values(). (Accelerometer)
  • upload – to copy a file from the computer onto the micro:bit so the program can run without the computer. (Your First Program)

V

  • value (colour) – how light or dark a colour is. (Colour Sensor)
  • variable – a named place in memory that stores a value our program can use and change. (Creating Your Program)

W

  • wireless – communicating between devices without any cables or wires. (Radio)