Skip to content
BENIBIX Learn

Programming Concepts

The building blocks of writing code · 76 terms

Sort
Compare

Programs

17

What a program is, who writes it, and the text it is written in.

The programs that tell a computer what to do. You cannot touch it, only run it.

A list of steps for a computer. It runs them in order to do a job.

A short program that runs straight from its text file, with no build step.

A tiny first program that prints Hello, world. It shows the tools work.

The text of a program, as people write it and read it.

A person who plans, writes, tests and fixes software for a living.

The rules for how code must be typed. One wrong sign and it will not run.

What goes into a program, and what comes out. Short form: I/O.

All the code of one project, kept together in one place.

A plan for a program in plain words. People read it, but no computer runs it.

Code Structure

7

The parts a line of code is built from.

A word the language keeps for itself, like if or return. You cannot reuse it.

One whole step in a program. Each is like a line on a to-do list.

A piece of code that works out to one value, like 3 + 4.

A note in the code for people. The computer skips it.

A file of code. Other files can import it and use its parts.

A group of lines that run as one, like the body of a loop.

The space at the start of a line. It shows which lines sit inside a block.

Data and Variables

23

How a program keeps values, and the kinds of value it can keep.

A named box in a program that holds a value. The value can change.

A named value that never changes. It stays the same the whole time a program runs.

The step that puts a value in a variable. Most languages use one = sign.

The kind of value something is. A number, a bit of text, or true or false.

A piece of text in a program. It is written inside quote marks, like "Hello".

Joining strings end to end to make one longer string.

A whole number, like 7, 0 or -12, with nothing after the point.

A number with a decimal part, like 3.5. It can be off by a hair.

A value that is only ever true or false. It works like a yes or no.

A special value meaning no value at all. It is not zero or empty text.

Changing a value into a new type. Text like "42" can become the number 42.

A type with a short, fixed list of named choices, like RED, AMBER and GREEN.

A group of 8 bits, each a 0 or 1. Computers count size in bytes.

Typing a value right into the code. To change it, you must change the code.

Collections

5

Values that hold many values, and how to reach one of them.

A row of values kept together under one name. Each sits in a numbered spot.

The number of a spot in a list. In most languages the first spot is 0.

A collection of key and value pairs. You look a value up by its key.

A group of values with no repeats. Each value is in it just once.

A small, fixed group of values in order. It usually cannot be changed.

Operators

4

The signs that add, compare and join values.

A sign like +, > or and that works on values and gives a result.

A sign that does maths with numbers: +, -, *, / and more, like %.

A sign like ==, > or != that compares two values and answers true or false.

The words and, or and not, which join or flip true and false values.

Control Flow

8

The order code runs in, and the ways to choose and repeat.

The order a program runs its steps in. Ifs skip lines; loops repeat them.

An if runs code only when a test is true. Else runs when it is not.

Checks one value against a list of cases and runs the one that matches.

Code that runs the same lines again and again. It goes until told to stop.

A loop that runs once for each item in a list, then stops by itself.

A loop that keeps going while a test is true, and stops when it turns false.

A loop that never ends. Usually a bug, and the program seems to freeze.

A line that stops a loop at once. Its partner continue skips to the next pass.

Functions

10

Named blocks of code, what goes into them and what comes back.

A named block of code that does one job. Write it once, use it many times.

A name in a function. It holds the value the function is given later.

The value you give a function when you call it, like 3 in area(3, 4).

The function gets a copy. Changing the copy leaves the first one alone.

The function gets a link to the real value. So its changes show outside too.

The result a function hands back when done. The return line sends it out.

The line that runs a function. You write its name, then brackets, like greet("Emma").

A function that comes with the language. You can use it with no import.

Where in a program a name can be seen. Names in a function stay local.

A function that calls itself on a smaller job. A stop rule ends the chain.

Errors

9

What goes wrong in code, the kinds of error, and how to find the cause.

A mistake in a program that makes it do the wrong thing, or stop.

A problem that stops code from working. Some stop it early, some mid-run.

Code that breaks the grammar rules of its language. Not one line of it runs.

An error that shows up while the program runs. Some input sets it off.

Code that runs with no error message but gives the wrong answer.

A loop or count that goes one step too far or stops one step short.

A signal that something broke mid-run. Code can catch it so the app does not crash.

The crash report. It lists each function call that led to the error.

The work of finding out why code goes wrong, then fixing it.

Development Practices

9

How teams plan and write code together, and the rules of thumb that keep it easy to change.

Team Practices

4

The stages a project moves through and the habits a team agrees on, from pairing to naming.

The stages software goes through, from first idea to being retired.

Two people write the same code together. One types and one checks.

A team rule for how to write names in code, like camelCase.

A team's written rules for how its code should look.

Design Principles

5

Short rules for shaping code so the next person can read it and change it safely.

Code that is easy for someone else to read and change.

The rule that each piece of logic should live in one place in your code.

The rule to pick the simplest design that does the job.

Do not build a feature until you really need it.

Five rules for building classes. They keep code easy to change.