// Binary Bits
Binary Code Translations
Every photo, song, game and message on a computer is really just a very long string of two symbols: 0 and 1. This unit is about cracking that code — and learning to translate between binary, decimal numbers, text and colour.
// The Big Idea
Binary is a 2-state system
Binary looks a little like this:
01000100 01101001 01100111 01101001 01110100 01100001 01101100 00100000 01010100 01100101 01100011 01101000 01101110 01101111 01101100 01101111 01100111 01111001 00100000 01010010 01110101 01101100 01100101 01110011 00100001 00100001 00100001
Why do computers use binary instead of the alphabet or the decimal (0–9) number system we use every day?
The answer comes down to circuits. Think of a simple circuit: a wire connecting a battery to a light bulb, controlled by a switch. That circuit can only ever be in one of two states — connected or not connected. We represent those two states with a 1 or a 0.
The decimal system has 10 states (0–9) and the alphabet has 26 states — both are much harder to represent reliably on a tiny circuit. Imagine trying to tell the difference between someone shining a torch at 30% brightness versus 70% brightness from across a room. Now imagine a computer chip with billions of those circuits, switching billions of times per second. Any small error in reading the signal would cause chaos.
It's much easier, and far more reliable, if we only need to tell the difference between “on” and “off.”
Watch: the lightbulb circuit
See how a single switch flicking on and off is the same idea as a binary 1 and 0.
▶ Watch the video.doc and .jpeg and how a computer knows whether to interpret a string of bits as numbers, letters, or colours — and how many different combinations (permutations) you could make with 1, 2, or 3 light switches.
// Place Value
Place value in a byte
Just like the 3 in 230 represents 3 tens in decimal, every position in a binary number represents a particular value. A group of 8 bits is called a byte. Each place value in a byte is double the one before it: 1, 2, 4, 8, 16, 32, 64, 128.
Try it yourself — click the switches below to flick bits on and off, and watch the decimal total update.
The key rule: adding up all the smaller place values always gives you exactly one less than the next place value up (1+2+4+8+16+32+64+128 = 255, one less than 256). That's why a byte can represent 256 different values: 0 through 255.
// Practice
Converting between binary and decimal
Here are three worked examples of binary numbers converted into decimal:
And three worked examples going the other way — decimal into binary:
// Working From Home
Catch-up video
If you're working through this at your own pace, this video takes you through the basics of binary conversion step by step.
// Your Task
Binary practice games
Play both of these games to sharpen your binary conversion skills. Give yourself 5 minutes on each.
Penjee Binary Bonanza
A fast-paced binary-to-decimal challenge with a scoreboard.
Open the game →💾 Save your evidence
After 5 minutes on each game:
- Take a screenshot showing your score / progress on each game.
- Paste both screenshots into a new Word document.
- Save the document into your Digital Tech folder — you'll keep adding evidence to this same document across this unit.
// Cracking the Code
Binary to Text
Computers store text the same way they store everything else — as binary. So how does a string of 0s and 1s become the letters, punctuation and symbols you're reading right now?
// History
ASCII: the original code
A common method for representing text is called ASCII (pronounced “as-kee”), which stands for the American Standard Code for Information Interchange. It was published in 1963.
128 possible codes
ASCII originally used 7 bits, giving 128 different possible codes, with an eighth bit sometimes used as a check bit to see if a message was received correctly.
Where the 8-bit byte came from
This design was based on early teleprinters, where paper tape could only fit eight holes across a line. A hole punched through the tape represented a 1. Eight bits can represent 256 different symbols — each line across the tape was one 8-bit character.
26 letters, upper & lower case, digits, punctuation
At the time, this seemed like more than enough: English has only 26 letters (upper and lower case), the digits 0–9, punctuation, and a handful of special symbols.
// Protocols
How ASCII assigns values
Computing systems need to understand the "rules" for interpreting a string of binary code — think about what happens when you try to open a file your computer doesn't recognise. ASCII assigns a decimal value to every uppercase and lowercase letter, number and commonly-used symbol.
For example: Y = 89, e = 101, s = 115 — so the word "Yes" would be encoded in decimal as 89 101 115.
Of course, a computer doesn't "understand" these numbers the way we do — over the actual circuitry or network cable, each of those decimal values is transmitted as its binary equivalent.
// The ASCII Table
Decimal · Hex · Character
Use this table to look up the character for any decimal (or hexadecimal) value between 0 and 127.
// Going Global
ASCII vs Unicode
ASCII was designed around the 26 upper- and lower-case Roman letters used in English. But computers everywhere need to handle far more than that — Russian and Arabic alphabets, Japanese and Chinese characters, emojis, and dozens of other writing systems.
ASCII
symbols, using 7 or 8 bits. Enough for English text, but nowhere near enough for the world's alphabets and scripts.
Unicode
characters, originally using 16 bits and now up to 21 bits per character — covering almost every writing system on Earth, plus emoji.
To make the switch easy, ASCII was built into Unicode as a subset. That means the decimal value 84 represents an upper-case T in both systems — so any old ASCII text is still valid Unicode text.
// Your Task
Translate binary into a message
Using the simplified ASCII table above, translate each string of binary code into decimal, then into its ASCII character. Here's a simple example of what your working should look like:
Now translate the following strings of binary code into a message (binary → decimal → ASCII):
💾 Save your evidence
Add your working to the same Word document you started in the last lesson (the one with your game screenshots). For each binary string, show:
- The binary code, copied in exactly as shown above.
- The decimal number(s) you calculated for each byte.
- The final ASCII character(s) — and what message they spell out.
// Interpretation of Binary — RGB
Binary Colours
How binary numbers become the colours you see on your screen.
Binary is binary. It's still a 2-state thing.
There's no point in changing the 0s and 1s into 3s and 4s, or into yellows and purples — so how can a binary number that gets translated into a decimal number also be used to represent a colour?
The only way binary code can be used for different purposes inside a computer comes down to how your computer is expecting to interpret it. This is where file extensions are very handy.
When you open a file that ends with .doc, your computer translates the sequence of binary numbers into characters, using the ASCII or Unicode character sets you just learned about.
If your file ends with .bmp or .jpeg, your computer instead interprets it as a graphical file, and uses an image-viewing program to display it. Each sequence of binary numbers is translated into colour values, instead of text-based characters.
If the binary code and the file type don't match up, you get an error — the file is "corrupted." Let's play with some binary sequences that make colours…
Different file types = different interpretations of the same binary data
From Bits to Colours: How Many Can We Make?
So far we've been painting with 3-bit colour — that gives us just 8 colours total. But real images need far more. Let's explore why, and what happens when we split those bits across Red, Green, and Blue light channels.
How many colours can n bits store?
Each extra bit doubles the number of possible colours. The formula is simple: 2n colours.
🔴🟢🔵 Mixing Colours with Light (Additive Colour)
Screens mix Red, Green, and Blue light to make colours — this is called additive colour mixing. Each channel gets its own 2-bit value: 00 (off), 01 (dim), 10 (medium), 11 (full). That's 2 bits × 3 channels = 6 bits per pixel → 64 colours.
The Full 6-bit Colour Gamut (64 colours)
Every combination of 00/01/10/11 for R, G, and B produces exactly 64 unique colours. This is what 6-bit colour looks like — hover any swatch to see its binary code.
// Your Task
🦋🦊 Design a binary creature
Using the pixelation widget, work on completing one of the images shown below — either the butterfly or the beetle. Your submission for this task will be a screenshot that shows the image, settings and code.
💾 Save your evidence
Once your butterfly or beetle is complete (or as far as you've gotten), take a screenshot of your creation and add it to your binary evidence Word document alongside your earlier work.
📄 binary-evidence.docx// Senior Computing · Extension · Logic Circuits
Logic Circuits
You've seen binary as a 2-state system — an electrical signal on a wire, or a + or − charge on a hard drive platter. Now let's use that 2-state idea to build the logic gates that are the fundamental building blocks of every computer ever made.
// Start Here
Before you begin
Watch this short video from Khan Academy and Code.org to understand what logic gates are and how they form the foundation of every computer ever built.
Circuits & Logic — Khan Academy × Code.org
A clear walkthrough of how binary signals, switches, and logic gates combine to perform real computations. Great starting point if you're brand new to this topic.
▶ Watch on Khan Academy// The Building Blocks
Logic gates & truth tables
Every circuit is built from just a handful of gates. Click the input buttons on each card to see the gate respond in real time — the output light will turn on when conditions are met.
// Your Mission
Build these circuits
Use the Logic.ly simulator to complete each challenge below. Read the hints and logic expressions carefully before you start wiring. Some of these are easy — some are really difficult!
Simple Switch Light
This is the simplest possible circuit — a direct connection from a toggle switch to a light bulb. No gates needed, but it sets the scene for understanding how inputs drive outputs.
Add a Toggle Switch and a Light Bulb. Draw a wire from the switch output to the bulb input. Click the switch to test.
Home Alarm System
Condition A: A window is open AND nobody is home (both must be true)
Condition B: A door is forced open (always triggers, regardless of anything else)
Either condition alone is enough to trigger the alarm.
Use three inputs: WindowOpen, NobodyHome, DoorForced. An AND gate handles Condition A. An OR gate combines both conditions.
Alarm = CondA OR DoorForced
Majority Vote Light
Useful in real life for voting systems and fault-tolerant circuits. You'll need AND gates and an OR gate. Think about every combination of two switches that could be active at once.
The light should turn on when: A AND B, or A AND C, or B AND C are on. Combine three AND gates and one OR gate (with 3 inputs).
Automatic Hex Counter
You'll need 4 bits of output to represent values 0–15. Use logic gates to control how each bit toggles based on the state of the bits before it. Connect your outputs to a 7-segment display to see the hex value.
Each clock input triggers the moment you release your mouse button — not when you press it. Wire up your logic gates first, then add and connect your clocks one at a time, testing carefully as you go.
Bit 1 toggles when Bit 0 is 1
Bit 2 toggles when Bits 0 & 1 are 1
Bit 3 toggles when Bits 0, 1 & 2 are 1
💾 Save your evidence
Attempt to build all four circuits above — you won't necessarily finish every one, and that's OK. For each circuit you attempt, take a screenshot of your circuit design and add it to your binary evidence Word document.
📄 binary-evidence.docx// How you'll be assessed
Assessment
You'll be assessed on the overall progress you make through this unit, and the evidence you're able to demonstrate along the way.
// Evidence
What to hand in
All of your evidence for this unit lives in one Word document, built up lesson by lesson. It should include:
- Screenshot images from each activity (games, ASCII translation, binary creature, logic circuits).
- Written text showing your working — especially for binary/decimal/ASCII conversions.
- A document saved in your Digital Tech folder, kept up to date across every lesson.
// Achievement Levels
How your evidence is graded
| Evidence | Achievement level |
|---|---|
| Evidence of progress in at least one of the binary practice games | Developing |
| Successful ASCII translation (binary → decimal → text) | Consolidating — Low |
| Binary creature (butterfly / beetle) completed | Consolidating — Mid to High (depending on % completed) |
| Logic circuit design | Extending — Low to High (depending on the number of circuits successfully designed) |