Glossary

Hiding the details behind a name so you can use something without thinking about how it works. You call drive_forward() without recalling every line inside it.

Designing so that as many people as possible can actually use the thing - including people who cannot see it, hear it, reach it, or hold it. A design that only works for some people is not finished.

Being the person a job belongs to, so the team can fairly ask how it is going. Accountability needs everybody to know who had what - and it only works when the asking is kind rather than accusing.

A part that produces movement. Motors and servos are actuators - they are the robot's equivalent of a muscle.

A list of steps that solves a problem. A recipe is an algorithm. So is the set of instructions you write for a robot.

An analog sensor reports a value across a wide range rather than just 0 or 1. A reflectance sensor answers "how dark is this?" with a number, so you have to decide for yourself where dark begins.

A piece of information you give a command, written inside its parentheses. motor() takes two arguments - the port and the power - separated by a comma.

A single name that holds a whole row of values instead of just one. You reach each value by its position number, so one name and a number can stand in for a dozen separate variables.

Software that uses information to work out what to do next, rather than following a fixed list of steps. Your robot reading a sensor and choosing an action is the same shape, just small enough to see all of.

Saying clearly where something came from when it is not yours. In code it means a comment naming whoever wrote the part you borrowed.

The machine moves around on its own. No person is controlling it while it runs. You start it and step back.

Everything between an opening brace and its matching closing brace. A block groups statements together so the controller knows which ones belong to which function.

A value that can only be true or false - nothing in between. Every condition you write comes out as a boolean, which is how the robot decides which way to go.

The line that marks the edge of a zone or area. Whether an object is inside, outside, or touching the boundary is often the difference between scoring and not scoring.

Somebody who sees unkindness happening but is not the one doing it or the one it is aimed at. Bystanders are usually the largest group, which is why what they do matters so much.

Measuring your own robot to find the numbers that describe it - ticks per inch, a light threshold, a turn count. Calibration is why one team's numbers do not work on another team's robot.

A small wheel that swivels freely instead of being driven. Pulled along behind the driven wheels it tracks straight; pushed from in front it wanders and has to swing round every time the robot changes direction.

A written list of everything that should be present or done, used to check the real thing against it. Engineers, pilots, and surgeons all use them, because remembering is unreliable and reading a list is not.

Forcing a value to stay inside a safe range. If a servo may only go from 200 to 1800, clamping turns any larger number into 1800 before it reaches the hardware.

A note for humans that the computer ignores completely. Single-line comments start with two slashes. Block comments start with slash-star and end with star-slash.

A saved snapshot of your work in version control, with a note saying what you changed. A good commit message tells a future reader why, not just what.

To translate the code you wrote into machine instructions the robot's processor can actually carry out. If compiling fails, the program cannot run.

The program that turns the code you wrote into instructions the robot's processor can carry out. When it finds something it cannot translate, it stops and tells you where.

The part of a robot that decides what to do. On your robot that is the Wombat running the program you wrote.

The question inside the parentheses of an if or a while. It compares two values and comes out either true or false. There is no in between - every condition is one or the other.

A limit your design has to stay inside - how big, how small, how much you have to spend, what parts you are allowed. A requirement says what it must do; a constraint says what it may not exceed.

The small computer that runs your robot. Yours is a KIPR Wombat. It holds your programs, powers the motors, and reads the sensors.

Using messages, posts, photos, or group chats to hurt, frighten, or humiliate somebody. It is different from a disagreement - it usually keeps going, and it usually has an audience.

Finding out why a program does not do what you meant, and fixing it. The skill is not writing perfect code; it is narrowing down where the trouble actually is.

A point where a plan splits two ways depending on the answer to a question. On a flowchart it is drawn as a diamond, with one arrow in and two labelled arrows out.

Breaking a big problem into smaller problems you can solve one at a time. Almost every hard robot task becomes easy once it is decomposed far enough.

The ordered set of steps engineers use to turn a problem into something that works. It is a loop, not a line - testing sends you back to change your design and try again.

A digital sensor has only two possible readings: 0 or 1. It works like a light switch - pressed or not pressed, with nothing in between. In programming, 1 means true, yes, on; 0 means false, no, off.

Behaving well in a place where you cannot see anybody's face. It covers how you treat other people online, how you protect your own information, and what you do when you see somebody being hurt.

The part of a robot that changes the state of the robot itself or the state of the world. Motors, arms, and legs are effectors, and so are buzzers, lights, and speakers. Its shape decides what jobs it is good at. A bulldozer blade pushes well and grabs nothing; a claw grabs well and pushes badly.

A PVC frame on the game field that objects can be placed inside. Missions that ask for something to be IN an enclosure are asking you to get it past those walls.

The counter built into a motor that reports how far its shaft has turned. On the Wombat, it is measured in ticks, and it is how a robot measures its own movement instead of guessing.

Scrambling a message so that only the intended reader can unscramble it. Anyone who intercepts it along the way sees nonsense.

Whoever the thing is actually being built for. Not you, and not the person marking it. They know things you do not, which is why you ask them before you build rather than after.

Somebody telling you what they actually saw, so you can make the thing better. It is not a mark and it is not criticism - people give it because they want the work to succeed.

A drawing of a plan, using shapes joined by arrows. Engineers everywhere use the same shapes, so a flowchart can be read by someone who does not speak your language.

A loop that repeats a known number of times. Its three parts - where to start, when to stop, and how much to change each time - all sit together inside one set of parentheses, separated by semicolons.

A named set of instructions. Calling a function means telling the controller to carry out everything inside it. A clean_house() function might mean vacuum, dust, and mop - you call it once and all of it happens.

The physical body of a machine - the parts you could drop on your foot. Hardware can do things but cannot decide anything.

A file ending in .h that holds functions you want other programs to be able to use. You bring it into a program with an #include line at the top.

Short for Integrated Development Environment. It is the place where you write your code, check it for mistakes, and send it to the robot. Yours is called the KISS IDE.

The position number that picks one item out of an array or list. Indexes usually start at 0, so the first item is index 0, not index 1.

A moving object keeps moving until something stops it. When your loop shuts the motors off, the robot is still rolling, so it coasts past the tick count you asked for. More speed means more coasting.

Information coming into a system from outside - a sensor reading, a button press, a light coming on. Without input a machine has no idea what is going on around it.

A whole number - no fraction, no decimal point. Servo positions, motor ports, and power levels are all integers, which is why they are declared with int.

Something a person made with their mind rather than their hands - code, writing, music, a design. It still belongs to whoever made it, even though you can copy it in a second.

A number that identifies one machine on a network - like a building address. Your browser uses it to find your Wombat.

The rule that turns a scrambled message back into a readable one. Whoever holds the key can read the message; whoever does not, cannot. Keeping the key safe matters more than keeping the method secret.

A collection of functions kept in a separate file that any program can include. Including the KIPR library gives your program every command it needs to run motors, servos, and sensors. Your own library gives you the commands you invented.

Python's way of holding a set of values under one name. You reach each value by its index, so one name and a number can stand in for many separate variables.

A point in a plan where something has to be finished before the next thing can start. Milestones are how you find out you are behind while there is still time to do something about it.

Building a program out of separate pieces that each do one job. Modular code is easier to test, easier to fix, and easier to reuse somewhere else.

A separate Python file holding functions you want to use elsewhere. You bring it into a program with an import line, the same way C brings in a header file.

The remainder left over after dividing. 7 modulo 3 is 1, because 3 goes into 7 twice with 1 left. It is how a program makes something repeat in a cycle.

One structure placed inside another - an if inside an if, or an if inside a while. The inner one is only reached when the outer one lets the robot get that far.

One wheel drives while the other stays stopped. The robot swings around the stopped wheel. Giving the moving wheel more power makes the swing faster, not tighter.

Something a system does to the world - a motor turning, a claw closing, a message on a screen. Output is the only part of a program anyone can actually see.

How far past your target the robot keeps going after the motors switch off. It happens because a moving robot cannot stop instantly. The faster you drive, the bigger the overshoot.

A small piece of a larger message, sent on its own. Big things do not travel well, so computers chop information into packets, send them separately, and rebuild the whole thing at the far end.

A flat platform on the game field that a load sits on. Several missions ask you to move a pallet and whatever is stacked on it, together.

A named slot in a function that receives a value when the function is called. The parameter is the slot; the argument is the value that gets put into it.

The lock on everything else you own online. A strong one is long, mixes different kinds of character, and contains nothing anybody could look up about you.

Anything that could be used to work out who you are, where you are, or how to reach you. Single pieces often look harmless - it is putting several together that identifies somebody.

A message that pretends to be from someone you trust so that you hand over private information without thinking. It usually creates panic or excitement so you act before you check.

A socket on the Wombat where you plug something in. Motor ports are numbered 0, 1, 2, and 3. The number in your code tells the controller which socket to send power to.

A number that tells the browser which service to reach on that machine - like which door to knock on. The Wombat's programming tools always use 8888.

Sensing your own body rather than the world outside it. Motor encoders are proprioceptive - they tell the robot how far its own wheels have turned.

The set of rules both ends agree on before any message is sent - how packets are numbered, what happens if one goes missing, how you know the message is finished. Without a shared protocol, arriving packets are just a pile.

A single line near the top of your program announcing that a function name exists, before the compiler ever reaches the code that does the work. Like listing a word in a vocabulary list before defining it.

Literally "false code." Your plan written in plain language as comments, before you write any real code. It keeps you from getting lost in the middle of a program.

Both wheels turn the same direction but at different speeds, so the robot sweeps a curved arc. How sharp the arc is depends on how different the two power numbers are. Also called an arc turn.

A computer program that takes information about you and uses it to suggest things you might like. The suggestions are only as good as the instructions the engine was given.

A sensor that shines a small light downward and measures how much bounces back. Light surfaces bounce back a lot and give a low reading; dark surfaces absorb the light and give a high one.

A person drives every movement in real time. The machine makes no decisions of its own.

The stored home of a project under version control - all its files plus the full history of every change ever made to them.

Something your design must do to count as working, written so it can actually be tested. "Strong" is not a requirement. "Holds a full can for thirty seconds without leaning" is.

The answer a function hands back to whatever called it. A function that returns a value can be used inside a calculation; a void function cannot.

A mix - the machine handles some things itself while a person directs the rest.

The punctuation mark that ends a statement in C. It does the same job as the full stop at the end of a sentence - it says this instruction is finished, move on to the next one.

A device that turns something physical - a touch, a brightness, a distance - into a number your program can read. Sensors allow a robot to gather information about the world instead of just assuming.

Combining readings from more than one sensor to work out something neither could tell you alone. Two sensors disagreeing is itself information.

A motor that rotates to a position you choose, rather than simply spinning. It has a range of about 180 degrees, divided into 2048 numbered positions, and holds at whatever position you send it to.

The arm that clips onto the spline and carries whatever the servo has to move. Where the horn points when you push it on decides where the servo's range of movement begins.

The instructions a machine follows. Software can decide things but cannot move anything on its own.

The toothed shaft on top of a servo - the part that actually turns. The teeth let a horn grip it in a fixed position instead of slipping.

What a system is currently doing or holding - where the robot is, what it is carrying, how many cubes it has stacked. State is the information a program keeps track of as it runs.

One instruction for the robot to carry out. Statements run in the order they are written, top to bottom, and each one ends with a semicolon.

Text stored as data - letters, digits, and spaces treated as characters rather than as a number you can do arithmetic with.

Something you could point at and agree on. A tangible goal is one where everybody would give the same answer to "did it happen?" - unlike "get better at robotics", which two people could argue about forever.

The number you choose as your dividing line. Readings below it count as one thing, readings above it count as another. A common starting point is halfway between your white and black readings, then you adjust from there.

One small step of the motor shaft. There are about 1820 ticks in one full revolution of the shaft. Ticks count the motor turning, not the distance travelled - how far that is depends on your wheels.

What you give up in order to get something else. New technology rarely just adds - it swaps one set of problems for another, and judging it means looking at both sides.

A name that holds a value. You set it once, then use the name everywhere instead of the number. Change the value in one place and every use of that name changes with it.

How fast something moves, measured in real units - ticks per second rather than a percentage of full power. Velocity holds steady as the battery drains; power does not.

A system that keeps every version of your files as you change them, so you can see what changed, go back to an older version, and work alongside other people without overwriting them.

A function marked void does a job but hands nothing back. ao() is void - it stops the motors but gives you no answer. Functions like digital() and gmpc() are not void, because they hand you a number.

The two wheels turn in opposite directions, so the robot spins in place without traveling forward or backward. Also called a pivot turn or spin turn. This is the turn you use when you need an exact angle.