Binary Numbers Explained for Programmers

Binary Numbers Explained for Programmers

by | 5 min read

Everyone knows that computers run on ones and zeros. This is because CPUs are made up of billions of transistors, which are basically just on-off switches.

Any code you write needs to be processed by a computer and therefore has to be converted to binary instructions to work.

It isn’t just the execution of code that uses binary, it is also used for the storage of everything in memory and any files that you write to disk. Everything is stored as ones and zeros.

Before we get into exactly how binary works, we need to look are existing number system.

Current number system

All our numbers are represented with the digits 0 to 9. So, that is 10 characters in total that we use to represent every number from 0 to infinity.

You probably remember, in school, numbers being represented by number columns.

Number Columns

We can only put up to 9 in each column and once we need to go above that we have to move on to the next column.

This is what we call the base 10 number system. Each column is a power of 10.


Everyone knows the base 10 number system, and it is probably the one everyone uses, as we have 10 fingers.

Binary Number System

What if instead of using 10 characters to represent all the numbers, we only use 2.

🚀 Are you looking to level up your engineering career?

You might like my free weekly newsletter, The Curious Engineer, where I give career advice and tackle complex engineering topics.

📨 Don't miss out on this week's issue

This would then be a base 2 number system, if those 2 characters are 0 and 1, then that is what we call binary.

If we go back to our 4 columns. If in the base 10 numbers system each column represents a power of 10, in the base 2 number system each column represents a power of 2.


With these 4 columns, the maximum number we can store in binary would be 1s in each column, which works out as 8 + 4 + 2 + 1 = 15. If you include 0 as well that is 16 numbers in total, 0 to 15.

Binary numbers can also be used to represent letters as well. In the basic ASCII character set, the first 7 digits used to represent are used to represent 128 different characters.

A = 0100 0001
B = 0100 0010
C = 0100 0011
D = 0100 0100
E = 0100 0101

The 8th digit is then added to allow for all the other special characters, for a total of 256 characters in total.

Å = 1100 0101
Æ = 1100 0110
Ö = 1101 0110

Other Number Bases

It is not just binary numbers that are used in programming, we often encode data into other number bases.

Emails are encoded using base64. So unlike binary which use 0 and 1, base 64 uses the characters capital A to Z, lower case a to z, numbers 0 to 9 and the symbols +, / and =.


Base 32 is typically used a lot as well. The benefit of base32 is that it only uses upper case letters A to Z and the numbers 0 to 7. As there aren’t any special characters, it is great for things like filenames or to be used in URLs.


And of course, we can’t forget base 16 which uses numbers 0 to 9 and letters A to F.

0 = 0
1 = 1
2 = 2
3 = 3
4 = 4
5 = 5
6 = 6
7 = 7
8 = 8
9 = 9
A = 10
B = 11
C = 12
D = 13
E = 14
F = 15

Base 16 is also known as hexadecimal and is most commonly used to represent colours in CSS.

Colours in hexadecimal are written as 3 sets of 2 characters.

Colours in Hexadecimal

Each set represents, Red, Green, and Blue respectively.

As we have 2 characters and a base16 number, the first character on the right is 16 to the power 0 which equals 1 and the second character is 16 to the power 1 which equals 16.

So, the highest number we can represent with two characters in hexadecimal is FF which would be 15 x 16 + 15 x 1 = 255.

FF in Hexadecimal

Therefore, #FF0000 would be red, #00FF00 would be green and #0000FF would be blue.

This gives us a total of 256 x 256 x 256 = 16,777,216 colours that can be represented with hexadecimal.

Data Sizes

We know computers need to store everything as 0 and 1. So, how do computer sizes relate to binary numbers?

Each binary number, 0 or 1, is stored as 1 bit in the computer.

There are then 8 bits to a byte 1000 bytes to a kilobyte 1000 kilobytes to a megabyte.

If we look at datatypes of variables we use in programming. An unsigned byte can store a number from 0 to 255. A byte is 8 bits, so it is an 8 digit binary number.

0000 0000
1111 1111

If we look at these as number columns, we have the left most 1 representing 2^7.

Number columns up to 2^7

If we add these up, it is no surprise we get 255 as the total.

2^7 + 2^6 + 2^5 + 2^4 + 2^3 + 2^2 + 2^1 + 2^0 = 255

Now, what about negative numbers?

A signed byte can only store between -128 to 127. The reason for this is we need to use one of the bits to store the sign of the number.

We use the left most bit for this purpose. If the left most bit is a 1 the number is negative and if it is a 0 the number is positive.

0000 0000 = 0
1000 0000 = -128

Signed numbers use what is known as the two’s complement representation.

Numbers 0 to 127 are represented in the same way we did above. However, for negative numbers, we count up from -128.

1000 0000 = -128
1000 0001 = -127
1111 1111 = -1

There are still 256 numbers that can be represented with this 8-bit binary number.

  • -128 to -1 = 128 numbers,
  • 1 to 127 = 127 numbers
  • and 0

The more digits a binary number has, the larger the number that can be stored. So, an int typically takes up 32 bits, which means it is a 32 digit binary number:

0000 0000 0000 0000 0000 0000 0000 0000

If it is a signed int we can store numbers just up to over 2 billion and if it is an unsigned int we can store just over 4 billion.

🙏 Was this helpful? If you want to say thanks, I love coffee ☕️ , any support is appreciated.


SOLID Principles: Do You Really Understand Them?

SOLID Principles: Do You Really Understand Them?

  • 16 June 2023
SOLID Principles are one of those things that every developer has heard of but few fully understand. If you use an object-oriented language…
Recursion explained with the help from Inception

Recursion explained with the help from Inception

  • 12 May 2023
People love to joke about recursion. As the saying goes: “In order to understand recursion, one must first understand recursion.” You will…
Python List Comprehension: With Examples

Python List Comprehension: With Examples

  • 20 February 2023
Working with arrays can be a bit of a pain in most languages. If you want to make changes to an array you need to use a FOR loop, a bit like…
Finally Understand Regular Expressions: Regex isn't as hard as it looks

Finally Understand Regular Expressions: Regex isn't as hard as it looks

  • 10 January 2023
There’s nothing like a regular expression to strike fear in the heart of a developer. Regular expressions (regex) are used for a lot of…
How I would learn to code (if I could start over)

How I would learn to code (if I could start over)

  • 06 January 2023
When I was 8 years old I learnt how to code. I learnt to code from an old BASIC book that my Dad had lying around from his ZX Spectrum. I…
Understanding Big-O Notation

Understanding Big-O Notation

  • 03 January 2023
It’s important when you’re writing applications especially, those that are going to be processing a large amount of data that you understand…
Stack vs Heap Memory - What are the differences?

Stack vs Heap Memory - What are the differences?

  • 30 November 2022
In modern programming languages such as C# or Java, we tend to take memory management for granted. Gone are the days when we need to call…
Git Flow vs GitHub Flow

Git Flow vs GitHub Flow

  • 10 November 2022
Losing code that you have spent hours writing can be painful, which is why we use version control (or source control) to store our code and…