Skip to content

Glossary

This glossary lists every technical term used on this site, in alphabetical order. Each term links to the page where it is first explained. Each page lists its new terms in a Terminology callout at the top. Terms already introduced in an earlier tutorial site aren't repeated in those callouts, but they are all listed here.

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 something moves or around which it turns. (Accelerometer)

B

  • background – running code on a schedule while the main loop keeps doing something else. (microbit Module)
  • Boolean – a data type that can only be True or False, called bool in Python. (Display)
  • breakpoint – a place we mark in our code where the debugger pauses the program. (Debugging with Thonny)
  • bug – a mistake in a program that causes unexpected results. (Debugging with Thonny)

C

  • calibration – testing and adjusting a sensor or device so its readings or movements are accurate. (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 line starting with # that Python ignores, written to help humans understand the code. (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, such as (x, y), that gives a position on a screen or display. (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 runs our code one step at a time so we can see what it is doing and find mistakes. (Debugging with Thonny)
  • debugging – the process of finding and fixing bugs in a program. (Debugging with Thonny)
  • define – to create a function with def, giving it a name and a code block that Python remembers but doesn't run yet. (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 whose condition is always True, so it never stops on its own. (Your First Program)

F

  • float – a number with a decimal point, like 1.0 or 3.5, short for floating point number. (Display)
  • for loop – a loop that repeats its code once for each item in a list or sequence. (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 we can run again and again whenever we need it. (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 something is facing, measured in degrees. (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 its indented block only when its condition is True. (Creating Your Program)
  • import – the command that tells Python to load a module so our program can use its commands. (Creating Your Program)
  • indentation – spaces at the start of a line (four in Python) that show which code belongs to a loop or other block. (Creating Your Program)
  • input – information that goes into a program, such as a key press, a mouse click or a sensor reading. (Creating Your Program)
  • integer – a whole number written without a decimal point, like 1 or 25, called 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 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 items stored in a set order inside [ and ], with commas between them. (Sound)
  • local variable – a variable that only exists inside the function that created it. (Debugging with Thonny)
  • logic error – a mistake where the code runs without crashing but doesn't do what we expected. (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. (Your First Program)
  • method – a function that belongs to an object or value, written after a dot, such as name.upper(). (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 file of ready-made code that we can import into our program to use its commands. (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 that means nothing, used when there is no value yet. (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 – information or actions that a program sends out, such as text on the screen, a sound or a motor moving. (Creating Your Program)

P

  • parameter – a variable name in a function definition that receives a value sent into the function. (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 – one of the tiny dots of light that make up a screen or display. (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. (Your First 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 collection where the first item put in is the first item taken out, like a line of people waiting. (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 value a function or method sends back to the code that called it. (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 – an error that happens while the program is running, which makes it crash. (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. (Your First Program)
  • Shell – the panel in Thonny that shows what our program prints and any error messages. (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 parts of the program that are currently running, such as the main program and any function it has called, which the debugger shows. (Debugging with Thonny)
  • string – a group of characters, like letters, numbers or symbols, inside quotation marks. (Display)
  • syntax error – an error that happens when our code doesn't follow Python's rules. (Debugging with Thonny)

T

  • temperature sensor – a sensor that measures how hot or cold it is, in degrees Celsius. (Temperature)
  • Thonny – a program for writing, running and debugging Python code that is designed for beginners. (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 group of values written in round brackets that works like a list but can't be changed. (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, like a labelled box, that stores a value our program can use and change. (Creating Your Program)

W

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