Learn about the binary numbering system and how computers process binary data into usable information.

Binary Numbering System

Converting from binary to decimal can get tedious, especially as our binary data grows in length. Lucky for us, converting from decimal to binary is very straightforward. 

The method we will use only requires us to be able to divide by `2`, hence its name, *Division-by-2 Method*.

Whenever we divide a number we always have two answers:
- the *result* (also known as *quotient*)
- the *remainder*

If our remainder is `0`, we normally don’t include it when we give the answer but it is still there.

- `35 / 7 = 5 remainder 0`
- `36 / 7 = 5 remainder 1`

When we divide by `2` we will always end up with a remainder that is either a `1` or a `0`, in other words, binary digits.

The Divide-By-2 method will continue dividing a number by two until the result, the first part of the answer, is `0`. The first time we divide, the remainder goes in the LSB column. Each time we divide after that, the remainder is written as the next digit to the left.

We can use our even/odd trick we learned to check if we've got the right digit in the LSB. Odds will always be `1`'s and evens will be `0`'s.

Follow along with the conversion of 2710 to binary:

| Dividend10 | Divisor10 | Result10 | Remainder10 | Cumulative Binary2 |
| --- | --- | --- | --- | --- |
|27 (odd)|2|13|1 -> LSB|1|
|13 (odd)|2|6|1|11|
|6 (even)|2|3|0|011|
|3 (odd)|2|1|1|1011|
|1 (odd)|2|**0**|1 -> MSB|11011|

 

**Answer: `27`10 = `11011`2

Decimal to Binary Conversion

Let’s reinforce what we learned in the previous exercise by practicing our counting to eight in binary. Eight may seem like a random number to stop at, but check out the table below and try to pick up the pattern of the counting.

|Decimal | Binary|
|:---:|:---:|
| 0 | 0 |
| 1| 1 |
| 2 | 10 |
| 3 | 11 |
| 4 | 100 |
| 5 | 101 |
| 6 | 110 |
| 7 | 111 |
| 8 | 1000 |

 

Each time we reach a power of two we have to add another digit. For example, when we reach the number `2` or 21, the binary value goes from `1` to `10`.

Similarly, when we reach decimal `4` (22), in binary we go from `11` to `100`. This pattern continues for all the powers of 2 (0, 2, 4, 8, 16, 32, 64, 128, etc).

In fact, this brings us to our first trick to figuring out a number in binary. The highest a binary number can be is **2n - 1**, where `n` is the number of digits in the binary number.

`011010001010` is 12 digits long; therefore, the highest number that can be represented in binary with these digits is `4095`:

212 - 1 = 4095

If we changed all the digits of our 12-digit binary number to `1`s, we get `4095` in decimal.

```
111111111111 = 4095
```

Our next trick you may have picked up yourself. You will notice that all odd numbers in binary end in `1` and all even numbers end in `0`. This is a quick way to double-check your work.

Counting In Binary

The ability to know the max size of a binary number allows us to check our work when we go to find the actual value of a binary number.

A five-digit binary number can never be more than `31`, or 25-1 because `11111` is equal to `31`.

To help keep our workspaces clear and concise, it is common practice to add subscripts to numbers when working multiple numbering systems in the same space.

`11111` and `31` from above should be represented as `11111`2 and `31`10 representing their bases for clarity. If no subscript is used, it is assumed to be a decimal number.

To convert from a binary to a decimal number, make a table like the one below. For every bit that contains a `1`, add that decimal number to the total. Let’s look at the 8-bit number `11001110`2.

![Decimal to Binary Conversion](https://static-assets.codecademy.com/Courses/Computer-Architecture/binary-conversion.svg)

Adding the decimal values of all the `1`s highlighted in yellow gives us:
(128) + (64) + (8) + (4) + (2) = 20610.

Binary to Decimal Conversion

Subtracting binary numbers is very similar to adding them, except now instead of carrying we are going to need to borrow.

Let’s subtract down from `8` and until we reach `4`.

|Decimal|Binary|
|:---:|:---|
|8 - 1 = 7|1000 - 1 = 111|
|7 - 1 = 6|111 - 1 = 110|
|6 - 1 = 5|110 - 1 = 101|
|5 - 1 = 4|101 - 1 = 100|

 


Here are some rules for subtraction:

- `1 - 0 = 1`
- `10 - 1 = 1`
- `11 - 1 = 10`

The key to any math problem is to take your time and check your work often. Subtraction is typically slightly more difficult simply because of borrowing and keeping track of the borrowed digits.

While not as important in addition, it is paramount in subtraction to place the larger number on top of the subtraction. If not, the result will be a negative number.

Here is an example of subtraction, pay close attention to how the borrowing in binary works out and try it out on simple problems first!

Ex. Subtracting `11`2 from `11010`2:
```
Binary | Decimal 
 | 
 11010 | 26 
- 11 | - 3 
------ | --- 
 10111 | 23
```

In decimal subtraction, you would borrow from the next digit. If the next value was a `7`, you would cross it out, make it a `6`, and bring the `1` over to your current subtraction.

In binary subtraction you do the same thing except you can only ever borrow from a `1` and it will always go to `0`. Just like in decimal, if the next digit is a `0`, you have to go to the next `1` and carry all the way down the numbers.

Subtracting Binary Numbers

Adding binary numbers can be done in much the same way that we add base 10 numbers, with a couple of caveats.

Let’s start at `0`10 and add until we reach `4`10:

|Decimal|Binary|
|:---:|:---|
|0 + 1 = 1|0 + 1 = 1|
|1 + 1 = 2|1 + 1 = 10|
|2 + 1 = 3|10 + 1 = 11|
|3 + 1 = 4|11 + 1 = 100|

 

We can see that when adding numbers we need to be very careful when carrying our numbers. This will happen much more frequently than we are used to with decimal numbers. Here are some important rules to remember when adding in binary:

- `1 + 0 = 1`
- `1 + 1 = 10`
- `1 + 1 + 1 = 11`

For larger numbers they can be lined up, one on top of another, just like in the regular addition you are used to. Take a look at the examples below, you can see how often you need to carry in binary addition.

Ex. Adding `100`2 and `1`2:
```
Binary | Decimal 
 | 
 100 | 4 
+ 1 | + 1 
---- | --- 
 101 | 5 
```

Ex. Adding `101101`2 and `111`2:
```
Binary | Decimal
 1111 | 1 <- carried digits
 101101 | 45
+ 111 | + 7
------- | ---
 110100 | 52
```

Adding Binary Numbers

Now that the fundamentals of addition and subtraction are under our belt, multiplication and division will be a cinch.

The great part about binary multiplication is that you only need to know your multiplication table up to 1!

|Binary Numbers | Result |
|---|---|
|`0` * `0` |`0`|
|`0` * `1` |`0`|
|`1` * `0` |`0`|
|`1` * `1` |`1`|

 

Yep, it's really that easy!

Here is the long-form standard decimal multiplication problem, `120` x `15`:

```
 120
 x 15
 ----
 600 
+ 1200 
 ----
 1800 <- Final answer
```

Binary multiplication follows this exact same process, multiply and then add the results together. For larger multiplication problems you would repeat step 3 as many times as the bottom number is long.

Let's do the same problem, `120` x `15` except in binary.

1. Line up problem, larger number on top, place values aligned:
```
 1111000
 x 1111
 --------
```
2. Multiply the top number by `1` of the LSB of the bottom number:
```
 1111000
 x 1111
 -------^
 1111000
```
3. Add a `0` to the next row and multiply all the top numbers by the next LSB (repeat as necessary):
```
 1111000
 x 1111
 ------^-
 1111000
 11110000
```
3. Repeat the same process for the next bit
```
 1111000
 x 1111
 -----^--
 1111000
 11110000
 111100000
```
3. Repeat the same process for the next bit
```
 1111000
 x 1111
 ----^---
 1111000
 11110000
 111100000
 1111000000
```
4. Add the results together
```
 1111000 
 x 1111 
 -------- 
 1111000 <- Add
 11110000 <- all
 111100000 <- these
 1111000000 <- together
 ----------
 11100001000 <- Final Answer
```

Binary Multiplication

You may find yourself asking why we go through all the bother of binary numbers when the decimal system has worked so well for humans for so long.

Unfortunately, computers only understand two states of being, off and on, represented by the bits `0` and `1` respectively. Computer hardware would be incredibly large, expensive, and resource-intensive if they were made to handle ten different states of data.

Binary data, when run through hardware, is seen as power applied or power not applied. An incredible level of precision and regulation would have to be built into the hardware to modify the applied electrical voltage so minutely as to fluctuate between ten levels of power.

Binary data also typically comes in specific lengths, for example, eight bits is called a *Byte* and two Bytes (16 bits) is called a *Word*. When the incoming data follows these guidelines, it is easy for the hardware to process and compute the desired result.

One common place you might see this is internet speed, which is typically expressed in kilobits or Megabits per second (kb/s or Mb/s).

File storage on your computer, however, is referenced in Byte size. For example, your favourite app might be 250 MegaBytes (MB).

When you buy Gig-speed internet (1 Gb/s), you may think you can download your favourite app in 0.25 seconds, but remember a Byte (file size) is eight times bigger than a bit (internet speed), so it will really take you 2.00 seconds, or eight times as long as you thought.

At the end of the day, it is all just a combination of `0`s and `1`s, off and on, that represents every piece of digital information you interact with, from the text on this screen to the color of the pixels in your profile picture.


Data moves from the left of the screen and into the CPU. Some data is good data and other data is bad. Under the CPU is a meter. When good data (words, nibbles, bytes) passes through the CPU, the meter moves toward the right. When bad data (unknown binary values) passes through, the meter moves towards the left.

Computers and Binary

Binary division is the last fundamental arithmetic we will learn, as most other operations are built on these four functions.

Just like in multiplication, binary division follows the same algorithm as its sister operation in the decimal numbering system. Also just like in the decimal system, dividing by zero is meaningless, or for our sake, impossible.

|Binary Numbers | Result |
|---|---|
|`0` / `1` |`0`|
|`1` / `1` |`1`|
|`0` / `0` |undefined|
|`1` / `0` |undefined|

 

To show the similarities, we will use the same numbers from the equation in our previous exercise on multiplication: `1800` / `120`.

![Decimal Long Division](https://static-assets.codecademy.com/Courses/Computer-Architecture/long-div-dec-final-cent.svg)


Alright, now let's work through all the steps of the process as we go about doing the same task in binary.

1. Set the problem up for long division. Make sure to put the divisor and dividend in the proper positions.
![Binary Division: Initial Stage](https://static-assets.codecademy.com/Courses/Computer-Architecture/long-div-bin-init-cent.svg)
2. Find the first instance that the divisor can subtract out of the dividend.
![Binary Division: Stage 1](https://static-assets.codecademy.com/Courses/Computer-Architecture/long-div-bin-1-cent.svg)
3. Carry the next digit from the dividend down to the result, if the divisor can subtract into it, place a `1` in the quotient and subtract, if not, place a `0` in the quotient and carry the next digit down until you can subtract.
![Binary Division: Stage 2](https://static-assets.codecademy.com/Courses/Computer-Architecture/long-div-bin-2-cent.svg)
4. Repeat the process until you have carried down the last digit of the dividend.
![Binary Division: Stage 3](https://static-assets.codecademy.com/Courses/Computer-Architecture/long-div-bin-3-cent.svg)
5. If the result of the last subtraction is `0`, then the problem is complete. Any leftover bits are considered the remainder, we will not do fractions and decimal division, even though the process is the same.
![Binary Division: Final Stage](https://static-assets.codecademy.com/Courses/Computer-Architecture/long-div-bin-final-cent.svg)

Binary Division

As the old joke goes:

> There are only `10` types of people in the world, those that understand binary and those that don’t.

By the time this lesson is over, you’ll be able to count yourself amongst the ones that do!

To get started, binary information is defined as *relating to, composed of, or involving two things.*

What we, as computer scientists, understand as examples of binary can be broken into two distinct categories:

1. Binary Numbers
2. Binary Data

Binary numbers are expressed as a combination of `0`s and `1`s. For example, `100110` is the binary equivalent of the number `38`.

Common examples of binary data include:
- Machine Code (`001010101100111001010010011`)
- Boolean Expressions (`True` or `False`)
- Hardware states (`On` or `Off`)
- Networking and File Storage

Before we start getting too far into how we use the data though, let’s take some time to really understand what binary data and the binary numbering system are.

Introduction

Numbers have been represented in a variety of different methods throughout history. For example, if you look at the face of some clocks, you may see that six o’clock is designated by `VI`, the Roman Numeral for `6`.

The most successful system of numbering is called the decimal system, from the Latin root **dec-** meaning *set of ten* or *having a base of ten*.

Although the exact origins of this system are unknown, it is clear that it began with counting on our fingers and later evolved into substituting the Hindu-Arab characters of `0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, and `9` for fingers in order to perform larger operations.

In the decimal system, each digit can be represented by a multiple of a power of ten and added together with the other digits. Let's look at the number `305`.

<img src="https://static-assets.codecademy.com/Courses/Computer-Architecture/decimal-table.svg" alt="305 in Decimal" height="100"/>

Starting at the right and moving left, the first column is the ones digit. The digit in this place value is `5`.

**5 times 100 =** `5`

The next digit, in the ten's column, is `0`.

**0 times 101 =** `0`

Finally, the `3` is in the hundred's column:

**3 times 102 =** `300`

By adding each column together, we get our total value:

```
5 + 0 + 300 = 305.
```

The binary system is very similar to the decimal system except it uses a base of two and only two digits, `0` and `1`. With the provided table we can use the same technique to evaluate `100110001`, which is `305` in binary. Try it out.

![305 in Binary](https://static-assets.codecademy.com/Courses/Computer-Architecture/binary-table.svg)

In binary, the digit that is farthest to the right is called the *Least Significant Bit* (LSB) and the left-most digit is called the *Most Significant Bit* (MSB).

Image shows a chart. On the left side of the chart are the numbers 1-10. The right side of the chart shows each of these numbers converted to binary.

Great work! Over the course of the last few exercises, you learned the fundamentals of binary numbers:

- Binary, is a numbering system of base 2
- Binary numbers are represented with the digits `0` and `1`. This can be expressed as:
  - `0` / `1`
  - `off` / `on`
  - `true` / `false`
  - or a variety of other binary terms
- Each binary digit is called a ‘bit’
- Binary numbers can be converted to and from other numbering systems such as decimal.
- Binary numbers can be added, subtracted, multiplied, and divided in much the same way as decimal numbers
- The left-most digit in a binary number is called the Most Significant Bit (MSB) and the right-most is the Least Significant Digit (LSB)

Binary data is the last stop your code goes through before entering into the computer hardware for processes and return.

When you write a program in Python, it gets translated by a compiler into a lower-level language, typically Assembly. From there it gets further refined into machine code and then sent to the computer hardware for processing.

In an upcoming lesson, we will discuss how the binary data is actually used by individual components of the computer hardware as well as how the entire architecture of a computer hinges on exactly how we write our binary data.
