2. Binary Arithmetic, Shifts & Characters

Once you understand binary numbers, the next step is learning how computers work with them. This chapter focuses on binary arithmetic – how values are added, what happens when results are too large, and how bit shifts can be used as shortcuts for multiplying and dividing.

You’ll also explore how text is stored in binary using character sets like ASCII and Unicode. By comparing standard ASCII with extended versions and Unicode, you’ll learn why different systems use different character encodings and how bit size affects the number of characters a system can represent. These skills are crucial for understanding everything from basic text files to global digital communication.

Just like decimal numbers can be added together, binary numbers follow their own simple set of addition rules. The key difference is that binary only has two digits – 0 and 1 – which makes the addition logic very consistent. 

The rules are:

• 0 + 0 = 0

• 0 + 1 = 1

• 1 + 0 = 1

• 1 + 1 = 10 (which means 0, and carry 1 to the next column)

• 1 + 1 + 1 = 11 (which means 1, and carry 1)
  
  

Binary addition is performed right to left, just like in decimal. As you move through each bit, you may need to carry a 1 to the next column. For example, when adding 00110110 (54) and 00011011 (27), the result is 01010001 (81).

Since this topic focuses on 8-bit binary, any value higher than 255 cannot be represented in this system. If an addition result goes above this, it leads to an overflow, which will be covered in the next subtopic.

Binary addition is essential for everything from arithmetic operations in code to how a processor handles logic and control.

In computing, an overflow error happens when the result of a calculation is too large to fit into the number of bits available. In an 8-bit binary system, the maximum value that can be stored is 255, which is 11111111 in binary. If you try to add 1 to 255, the answer should be 256 – but that requires 9 bits: 100000000. Since the system can only hold 8 bits, the leftmost (9th) bit is lost, and the result wraps around to 00000000, which is 0.

This creates a serious problem: the computer thinks the answer is 0 when it should be 256. In some systems, this kind of overflow could cause a calculation to restart from zero or produce a completely incorrect result. In real-world scenarios, overflow errors can lead to incorrect data, bugs in programs, or even system crashes if not properly handled.

Overflow is especially important in programming, games, and low-level data operations, where precise control of values is essential. Many systems include overflow flags or checks to prevent or catch this issue.

Binary shifts are a fast and efficient way for computers to multiply or divide binary numbers by powers of two. In a left shift, all the bits in a binary number are moved one place to the left, and a 0 is added on the right. This has the effect of doubling the number. For example, 00001101 (which is 13 in denary) becomes 00011010 (which is 26) after a left shift.

In contrast, a right shift moves all the bits one place to the right. The bit on the far right is lost, and a 0 is usually added on the left (for unsigned values). This effectively divides the number by 2, rounding down. So, shifting 00001101 (13) to the right becomes 00000110 (6).

Each shift multiplies or divides the original number by 2, and multiple shifts can scale numbers up or down very quickly. Binary shifts are often used in low-level programming, graphics processing, and situations where performance is critical, because they are much faster than using multiply or divide commands.

When computers store and process text, they need a way to represent letters, numbers, and symbols using binary. This is done using a character set – a predefined list that maps each character to a specific binary value. For example, the uppercase letter 'A' is represented by 01000001 in the ASCII character set.

Each character – whether it's a letter, number, space, or symbol – has its own unique binary code in the set. When you type a message or open a text file, the computer reads the binary values and translates them into readable characters using the correct set.

These binary codes must be standardised so different systems and programs can communicate properly. If one computer uses a different set of codes, the text may not appear correctly. That’s why using recognised character sets is so important in software, websites, and data transmission.

ASCII, which stands for the American Standard Code for Information Interchange, is one of the oldest and most widely used character encoding systems. It assigns each character – such as letters, numbers, punctuation, and control codes – a unique binary value so that text can be stored and transmitted by computers.

Standard ASCII uses 7 bits, which allows for 128 different characters (from 0 to 127). This includes all uppercase and lowercase letters, digits 0–9, punctuation marks, and special control codes like "Enter" or "Backspace." For example, the character 'A' is represented by binary 01000001, which is 65 in denary.

To allow for more symbols, Extended ASCII was developed, which uses 8 bits, allowing for 256 characters (0 to 255). This includes all the standard characters plus foreign letters, accented characters, and graphical symbols. Although modern systems use more advanced encodings like Unicode, ASCII is still used in older devices, simple systems, and some forms of data transmission where only basic characters are needed.

As computing became global, ASCII was no longer enough to represent the world’s languages and symbols. This led to the creation of Unicode – a universal character set designed to represent almost every character used in modern and historic writing systems. Unicode can currently represent over 143,000 characters, including alphabets, numbers, punctuation, non-Latin scripts, mathematical symbols, and even emojis.

Unicode supports a wide range of languages including Arabic, Chinese, Hindi, and Greek, making it essential for international communication, websites, and global software. It also ensures that text files display correctly across different devices and platforms.

One of the most commonly used encoding formats for Unicode is UTF-8 (Unicode Transformation Format – 8 bit). It is designed to be backwards-compatible with ASCII, meaning the first 128 characters are identical to standard ASCII. UTF-8 uses 1 to 4 bytes depending on the character, allowing it to store simple English text efficiently while still supporting more complex characters when needed.

The number of characters a computer can represent depends on how many bits are used for each character. This is because each bit can be either a 0 or 1, and the total number of possible combinations increases as you add more bits. The formula used to calculate the total number of combinations is 2ⁿ, where n is the number of bits.

Using this formula:

• 7 bits gives 2⁷ = 128 characters (used in standard ASCII)

• 8 bits gives 2⁸ = 256 characters (used in extended ASCII)

• 16 bits gives 2¹⁶ = 65,536 characters (used in Unicode formats like UTF-16)

The more bits you use, the more characters can be represented – which is essential for supporting different languages, symbols, and technical characters. However, more bits per character also means that more memory is used, especially in large files. Designers of character sets and systems must therefore balance storage efficiency with the need for flexibility and global communication.