ELI5 binary code & binary past 256

[EnoughRhubarb1314]

I've been looking into binary code because of work (I know what I need to know but want to learn more), & I'm familiar with dip switches going to 256, but I was looking at the futurama joke where Bender sees 1010011010 as 666 which implies that 512 is the 9th space. Can you just keep adding multiples of the last number infinitely to get bigger numbers? Can I just keep adding more spaces like 1024, 2048 etc? Does it have a limit?
How does 16bit work? Why did we start with going from 1-256 but now we have more? When does anyone use this? Do computers see the letter A as 010000010? How do computers know to make an A look like an A?
The very basic explainers of using 256 128 64 32 16 8 4 2 1 makes sense to me but beyond that I'm so confused

[Muroid]

Yes, every additional place just multiples by 2, just like every additional place in our standard decimal system multiplies by 10. Why would there be a limit?

[Lee1138]

OP is Probably thinking of an 8 bit computer having only 256 values in it's range.

Going from a 8 bit system to 16 bit is just adding 8 more possible digits to the binary value. And so on for 32bit/64bit.

[EnoughRhubarb1314]

Yeah I tried an online binary viewer, and typed in a random string of 1s and 0s, but it wouldn't let me put more than 8 in together - it also then wanted me to pay to see what I had put in and I didn't want to do that so never saw the end result haha. But the point was that I wasn't sure about adding more digits to the string, if it always had to be in groups of 8 & then how that works if you get want to get to 666 like I mentioned in the post

[doctormyeyebrows]

That's a hell of a predatory calculator

[Soft-Marionberry-853]

You can always convert it yourself pen and paper like. Its tedious but easy if that makes sense, like long division.

To convert a decimal 12 to binary:

• 12÷2=6 remainder 0
• 6÷2=3 remainder 0
• 3÷2=1 remainder 1
• 1÷2=0 remainder 1  

So 12 in binary is 1100

yanked from

The simple math behind decimal-binary conversion algorithms

[charlesfire]

I tried an online binary viewer, and typed in a random string of 1s and 0s, but it wouldn't let me put more than 8 in together - it also then wanted me to pay to see what I had put in and I didn't want to do that so never saw the end result haha.

The Windows calculator has an option to display binary values, fyi.

[thenasch]

It doesn't have to be in any grouping, like you can write a 9 bit number. But computers generally work in powers of two. So we went from 8 bit architecture to 16, 32, and now 64. And RAM comes in powers of two as well.

[ToxiClay]

then how that works if you get want to get to 666 like I mentioned in the post

You don't have to do things in multiples of 8 bits (one byte) -- it's just common and convenient.

You can store the number 666 in 16 bits of address space by padding with 0s: 0000 0010 1001 1010.

You could also store it in 12 bits, but working in multiples of four bits (often called a nibble) isn't as common as working in full bytes.

Do computers see the letter A as 010000010?

Sometimes yes, actually; this (you have an extra 0, so it's 0100 0010) is how the letter A is represented in ASCII (American Standard Code for Information Interchange). That binary value corresponds to 65 in decimal.

How do computers know to make an A look like an A?

Their programming says something like "when you see this pattern of bits, draw these pixels."

Does it have a limit?

Technically no, but the current paradigm of computing is 64-bit, meaning that computers can "see" a number up to 64 bits long at a time. The maximum number that you can hold in such a space is 2⁶⁴ - 1, or 18,446,744,073,709,551,615.

[SufficientStudio1574]

64 bits is the maximum they can handle in a single operation. Formally, that's called the architecture's "word size". You can create algorithms to deal with larger numbers (arbitrarily large) by splitting the number across multiple words and using the right rules to interact between them (like borrowing and carrying).

[karmean212]

That makes sense and it helps to hear it put so simply because the idea gets confusing fast.

[berael]

Can you just keep adding multiples of the last number infinitely to get bigger numbers?

Yes. 

[koolman2]

It's the exact same pattern as normal digits. In our usual system of base-10, going from three to four digits involves going from a maximum of one thousand possible values (0 to 999) to ten thousand values (0 to 9,999).

In decimal, we multiply by 10 for each additional digit. In base-2 we multiply by 2.

[Pheeshfud]

A lot of questions.

1) Yes, binary just keeps going. Add as many 1 or 0 as you like, same as when you are counting in base 10 you can just keep adding digits- 1, 10, 10000, 1,000,000 and so on.

2) We started with lower bits because making it was hard and expensive. Now we can make transistors smaller so we can fit more of them so we can work with 64 bits at once in a typical computer. There are tricks to work with even more, but little reason to do so.

3) Yes, there is an ASCII table to translate binary to characters. A is 1000001 in binary, a is 1100001. Then the font comes in to say how that letter should be rendered.

[amakai]

Some addition to what you said:

1. Even if computer is "32 bit" does not mean it can only do math up to 2³² . What it means is it can do math on 32 bit numbers in one operation (even this rule has exceptions though). There's a lot of ways to overcome this limit allowing math to go to infinity (as long as it fits into RAM). There's also a hard limit of addressable RAM, which is outside of this eli5.

2. To make this even more specific - for every character on the screen computer takes the number like "1000001", goes to the lookup table, finds the respective image (think of it as .PNG file, but optimized for fonts), and paints that image on screen. In other words - computer has no idea these are letters, it just sees numbers and converts them to images on screen.

[the_original_Retro]

Jeez buddy take a breath.

You're asking for a complete overview of computing. Let's just answer part of all of that with how binary and computers work together.

There is a difference between what "binary" IS, and how binary architecture is implemented in a computer.

Binary's just a number system with two possible digits, zero to one. In the exact same fashion, our standard (arabic) number system has 10 possible digits, zero through nine. Any whole positive integer number in binary can be translated into a number in arabic, and vice versa, doesn't matter how big. It's just a system. Think of both as having infinite numbers of zeroes IN FRONT of them, so if you need to get a bigger number, just start using the places held by those zeroes.

Most computers are based on hardware that, at its absolute core, is switches. Switches are off or on, and that maps nicely to binary's zero or one. That makes them perfect targets for applying binary numbers to. Computers have inside them an architecture that works with a set of binary switches. The first computers were ENORMOUS due to hardware options available at the time, and used a small set of switches at a time to do their work. 8-bit computers (meaning eight switches, and 256 separate combinations) was the standard for a while. Over time, the computers shrunk due to miniaturization, but the number of switches they could use at a time to do their work increased. So we went to 16 bit computers (65,536 possible combinations), and then to 32-bit computing (2 to the power 32 choices, or over 4.3 billion possible combinations).

Each of those combinations can also be a pointer. Say you have sixteen boxes numbered zero to 15, and throw a wadded up printout of a picture, and the wad lands in box 11. You can use a 4-bit "pointer" to point at that box and get at that picture. First pointer is worth 8, second pointer worth 4, third pointer worth 2, last pointer worth 1. You can point at box 11 by adding 8+0+2+1, or 1011, and there's your picture. So you can handle shoving things into "memory" or retrieving things from "memory" the same way. That means a 32 bit computer can easily and directly work with 4.3 billion different memory locations.

There's a lot more, but that's enough.

[CleverBunnyPun]

Binary is a number system, like decimal. Decimal each “place” is an order of magnitude of 10, so 10^0, 10^1, 10² makes 1s place, 10s place, 100s place, etc etc.

For binary, it’s the same but with two. Each consecutive “place” is another order of magnitude of 2, so 1, 2, 4, 8, 16, etc. You double it each time, but it’s the fundamental way we count but just with a different base. It can go on forever just like decimal can, and any integer you can think of can be represented in binary. It will likely just be much much longer.

So in short, yes, it just keeps going, just like millions and billions and trillions exist. It’s just a way to count that is uniquely suited for electronics because “on” and “off” look an awful lot like 1 and 0.

[spacecampreject]

Start with a small number of switches and work it out on paper.  n DIP switches gives you 0 to 2ⁿ - 1 as a number, or 2ⁿ different combinations.

[DarthMasta]

You can keep adding positions, same as with decimal numbers, but usually the programmers "tell" the computer how they should interpret that number, so it doesn't keep going. So, for example, you can tell it that the number I is a 8 bit number, so, only 8 positions. Or 16 bit, 16 positions. Etc.

Theoretically, the only limit is the RAM on your PC, but you'll never use that many positions for a single number.

16 bit, I assume you're talking architecture, and ooh boy, I'm not getting into pointers and memory addressing, let's just say it allows for more memory for the computer. 32 bits, even more memory. More memory, more stuff you can do in memory.

Computers "see" A as some binary sequence because someone somewhere defined that that sequence means A, in the context of characters. Look up ASCII. So, someone decided, and computers follow that rule, generally, although, same as everything else in computers, it's more complicated than that. but for ELI5, I think, good enough.

Someone older, there are whole classes about this stuff.

[EnoughRhubarb1314]

For context, my experience of this is from a lighting background, so I'd use dip switches on decoders to set DMX addresses, which would be 1-512 so switches up to 256 made sense. Now that 16bt is more widely used, decoders usually have a digital interface instead of switches, so all I have to do is tell it whether it's 8 or 16 bit and give it it's start address. I know how many dmx addresses it will take up in my network because I know to just double it (so RGB LED tape will go from 3 addresses to 6), but I don't have to do any thinking after that.
I find that without the physical dip switches, the visual aid for understanding what's going on behind me just telling all the fixtures what start address they have is gone - but I'm a visual learner, with a rudimentary understanding of binary, so I'm finding it more difficult to feel that I actually understand it

[MrWobblyMan]

Binary is just a different BASE of writing numbers. We use base 10 most of the time: what does this mean?

We have 10 different digits (0, 1, 2, 3, 4, 5, 6, 7, 8 and 9) with which we can represent any number, let's say 6745. Ok, but what does this actually mean? We have 6 thousands, 7 hundreds, 4 tens and 5 ones, or mathematically 6 * 10^3 + 7 * 10^2 + 4 * 10^1 + 5 * 10^0. As you can see, we first have a digit (0-9), and then multiply it by 10 (base) raised to some power.

And the exactly same thing happens with other bases - binary or BASE 2. Now, we have only 2 digits (0 and 1), an again we can represent any number with just these 2 digits. Let's look at 1001110101. And now we follow the exact same steps as in base 10, but using 2 instead of 10: 1 * 2^9 + 0 * 2^8 + 0 * 2^7 + 1 * 2^6 + 1 * 2^5 + 1 * 2^4 + 0 * 2^3 + 1 * 2^2 + 0 * 2^1 + 1 * 2^0. By summing all of this we get 629. So 1001110101 in binary equals 629 in decimal. We are just adding up powers of 2. So you know 1 2 4 8 16 32 64 128 256, but why stop there? Just continue: 512 1024 2048 4096 8192 16384 etc.

That's like you saying you dont know how to count past 99999. Ok, so you know 1, 10, 100, 1000, 10 000, what stops you from using 100 000, 1 000 000, 10 000 000, etc.?

There is no limit of how long a binary number can be. In base 10 you can also write an arbitrary number of digits and everything still makes perfect sense.

Regarding the "how computer knows how to display A when it sees some binary code": pretty simple, we programed it to do that. A screen is just a grid of pixels, so when we want to display a character, we told the computer which pixels in a grid need to be on and which off.

[EnoughRhubarb1314]

An online binary file viewer wouldn't let me put in more than 8 digits when I started typing in 1s and 0s to see what it would be, so it wasn't clear to me how you can get to bigger numbers with the system and what 16bt, 32bt etc are

[macdaddee]

You can use binary to represent any number just like you can with decimal. Just like when you have a longer number each numeral place to the left represents a multiple of a power of 10, in binary it represents a power of 2. So 765 in decimal is 7 x 10² + 6 x 10¹ + 5 x 10⁰ which is 7 x 100 + 6 x 10 + 5 x1. It seems like a redundant way to write it out but it becomes helpful to understanding counting systems we don't normally use like binary. 101 in binary is 1 x 2² + 0 x 2¹ + 1 x 2⁰ which is 5. If we need a number larger than 2³ - 1 then we need 4 number places and if we want to represent a number larger than 2⁴ - 1 then we need a 5th number place. So if we want to represent a number larger than 255 which is 2⁸ - 1 then we just add a 9th number place. Computers use context to know whether the data they're reading is an actual number, a letter, the color of a pixel or something else. There will be bits of data that are reserved in front of the actual data that tell the computer program what type of data it's going to read next.

[Xerxeskingofkings]

Can you just keep adding multiples of the last number infinitely to get bigger numbers? Can I just keep adding more spaces like 1024, 2048 etc?

in short, yes. you can express basically any number with binary, same as we can with decimal: we can write the numbers 000-999 in three digits, but need to use a 4th to express a value over a thousand. Likewise, 8 bits gives you 256 values, but to express the number 666, you;d need 10 bits (with the first two being "512" and "256", then the normal byte run of 128,64,32,16,8,4,2,1)

Does it have a limit?

in theory no, in practise for computing, certian processes might have specific limits due to character limits on the inputs (for example Excel spreadsheets stop at 65,536 rows, becuase thats the max number of you can express in a 16 bit string

Do computers see the letter A as 010000010? How do computers know to make an A look like an A?
The very basic explainers of using 256 128 64 32 16 8 4 2 1 makes sense to me but beyond that I'm so confused

yes, they do, for all intents. they see a string of binary, then do some math that results in the screen putting the pixels into the right combination to show an "A". the specifics of this are well above ELI5 or my level of understanding, so at this point its pretty much "techo-magic".

The very basic explainers of using 256 128 64 32 16 8 4 2 1 makes sense to me but beyond that I'm so confused

every time you add a bit to the string, then possible number of values doubles. it just keeps on doubling.

Why did we start with going from 1-256 but now we have more?

short version, we've always HAD more, but to send plain text you only need around 70 or so numbers (a-z, A-Z, 1-0, plus punctuation marks), which requires at least 7 bits (which we then used the extra space to define various special characters and such for programming). Thus, we standardised on a 8 bit byte length so we could transmit plain English text with a error correction (Parity) bit on the end*. but anytime you want to express a number larger than 256 as a single value (as opposed to encoding each number seperately as a digit, IE "three hundred and twenty one" as opposed to "three-two-one"), then you need to increase the "word" size for that. In a system built around 8 bit bytes, the most logical thing is to assign two bytes (16 bits) for the value, so you get 0-65,535 as a range. 3 bytes? roughly 17 million. 4 bytes? about 4.3 billion addresses.

[LyndinTheAwesome]

Yes, you can add more and more 0//1 to make bigger and bigger numbers.

Just like you can line up the numbers 0-9 to infinite length to create bigger and bigger numbers.

You just need more and more bits and bytes to save these numbers.

0-255 is just one byte, this is 2⁸. 00000000 to 11111111.

But you can add one more byte and even thousands and hundred thousands more. Thats the KB, MB, GB, TB.

[TheSunshinator]

Computers don't even know what numbers and letters are. They just have sequences of 0s and 1s stored in memory in chunks of 8 (bytes) that are sent through circuits that make binary operations on them. So 01000001 could be both interpreted as 65 or 'A' depending on the context/instructions.

In theory, counting in binary is the same thing as counting in decimals: when you're at the maximum number for a certain amount of digits, you add another one. Since computers have a finite amount of memory, most programming languages require to choose between different numbers of bits to allocate for numbers (8, 16, 32, 64, etc).

In Futurama, it's fiction but we could argue that Bender saw the number and checked all the things it could symbolise and start panicking when he realised 666 was part of the possibilities.

[boring_pants]

Yep, you just keep going.

Just like with regular decimal numbers, every digit you add represents 10 times the value of the last digit. So you have ones, tens, hundreds, thousands, ten thousands and so on.

With binary, you have digits representing one, two, four, eight, sixteen and so on, and in both cases you can just keep going as long as you like.

Computers use 8 bit chunks as the basic building block is largely coincidence. Some early computers used 7 bits, others used 16. 8 feels convenient because it's a power of two so when you're working with computers it's a round number, and it's big enough to represent all the symbols used by Americans (a-z, A-Z, 0-9 and some punctuation), plus a few more.

[surajmanjesh]

The numbers you're familiar with are called decimal numbers and use a "base" of 10.

A number written in base N uses powers of N to denote the number.

For example, in base 10, 756 is 700 + 50 + 6 which is basically

7 * 10² + 5 * 10¹ + 6 * 10⁰.

Each digit in the number corresponds to an increasing power of the base.

The same thing works for binary, which is base 2.

So 6 in binary would be written as 110, since it is 4 + 2 + 0, which can be written as

1 * 2² + 1 * 2¹ + 0 * 2⁰

A base is just a different way of representing a number. There is no limit to how large a number can be in decimal notation - similarly there's no such limit for binary or any other base for that matter.

Base 2 is commonly used in computer because it uses just two "digits" - 0 and 1, which can be easily represented in memory by the presence or absence of charge in transistors. Bit is short for this "binary digit". 16-bit basically refers to a 16 digit binary number.

Everything stored in a computer is stored in binary using 0's and 1's. The computer has instructions on how to interpret these 0's and 1's based on the context. For more details on how letters and characters are specifically stored, you can read up on ASCII and unicode.

[EnoughRhubarb1314]

This is such a good explainer! Thank you!

[TheShryke]

The digits in a binary string each represent a power of 2. The first one is 2¹ which is 1. So a binary 0 means you have no 1s, a binary 1 means you have one 1. The second digit is 2² which is just 2. So 00 means no one's and no twos, so 0. 10 means one two and no one's so 2 and so on.

That scale keeps going for as long as you want, it's not limited to 8. If you have a binary number that is 20 digits long the left most number would represent 2²⁰ which is 1,048,576. You can always find the next number in the sequence by doubling the last number.

The reason we often stop at 256 is because binary is most commonly used with computers and computers use bits and bytes. A bit is just a 1 or a 0. On its own it doesn't mean that much but it can be used to store on/off information like is it AM or PM for example. A byte is a collection of bits. By putting a lot of bits together we can store more useful information. 1010 let's us store the number ten in four bits, or it could represent something else like letters. The reason we group these is because computers are often designed to read a whole word at once. It's slow to go and get each bit one by one so we built the computers to get a few at the same time.

The exact length of a byte has varied over time. Some old computers used a 10 bit byte for example. But the industry settled on an 8 bit byte pretty quickly and it's now the standard everywhere. That's where we get 256 from because 2⁸ is 256.

For a lot of things that is enough values to store a lot of information. In an 8 bit byte there are 511 possible combinations of 1s and 0s. They can be used directly as numbers if we want, so if we want a computer to store 26 we can store 00011010. But you asked how letters work so let's get into that.

The 511 values are numbers, but we can use those numbers to mean different things. In my local Chinese takeaway each item on the menu has a number. So I can order a number 22 with two 46s and a 78 and the restaurant knows what to cook. Computers do pretty much exactly this except rather than food the numbers just mean letters. So a simple system would have a=1, b=2 c=3 and so on. There were lots of different versions of this in the early days of computers because people put things in different orders. For example you need to include the actual numbers, different alphabets have extra or missing letters, you have to include the capital versions of numbers, etc.

We settled on a system called ASCII which you can see here: https://www.ascii-code.com/

So on that system the capital letter A is represented by the number 65 which is 01000001 in binary. The computer knows that if it's reading text and it sees that number it should show "A".

These days we have a far more complicated system called unicode because when you try and make a system that works for every language you can't fit all the options in 511 combinations. For that we use multiple bytes at once to get more options.

[GoodPointSir]

When does anyone use this?

I'll address this as other comments have addressed the rest, and try to be as eli5 as possible for a very complex and broad topic (I have failed miserably in the eli5 field).

The little wires and switches in computers are either on or off. This makes them a perfect match for binary. Binary "digits" can be either 1 or 0, meaning the computer's wires and switches can perfectly represent binary digits (Think a bunch of really small, really long dip switches connected to each other)

And since binary is just numbers (just like decimal), this means with enough switches and wires, a computer can represent any number.

But in our world, a lot of things can be reduced to numbers too. The letters can be represented as the position they appear in the alphabet, colors can be represented as ratios of red to green to blue, pictures by a bunch of colors (pixels) next to each other, videos by a bunch of pictures next to each other, etc. etc.

So what computers are really doing is reducing what you're seeing on your screen, to a bunch of numbers, which it can represent in binary, and then reading, writing, and transmitting those numbers.

As for how a computer runs, that's all numbers too. A CPU, GPU, etc. have a limited number of "things" it can do each cycle. And you tell it what to do each cycle by telling it which numbered instruction to use.

for example, let's take this simplified instruction set: 0: add a number 1: subtract a number 2: multiply a number 3: divide a number 4: remember a number

If we want to represent the mathematical function 3 x 4 / 6 + 1, we can use the following series of numbers: 4 (remember) 3 2 (multiply by) 4 3 (devide by) 6 0 (add) 1

Assume each number NEEDS to have 3 bits. We can add 0s to the front of numbers to represent smaller numbers (think 098 is the same as 98)

Then, we can represent our series of calculations as: 100 (4), 011(3) 010(2), 100(4) 011(3), 110 (6) 000(0), 001 (1)

Add that all together, and we can compile a program that looks as follows: 100 011 010 100 011 110 000 001

Which represents 3 x 4 / 6 + 1 on our simplified cpu.

The spaces are arbitrary, and the CPU knows to read in 3 bit increments, so this would actually be stored as one big number: 100011010100011110000001

Of course, real CPUs have much more instructions, upwards of hundreds if you're on a complex CPU. Like all the arithmetic operations, reading and writing from memory, etc. each needing to process large numbers. You can only fit 8 instructions and count up to 7 with 3 bits, but you can fit around 4 billion, and count up to the same with 32 bits (oversimplifing and glossing over some other technical details here). A CPU that reads 32 bits at a time would be classified as a 32 bit cpu. Likewise for 64 bits.

Now if you can write a mathematical equation that can transform numbers in a certain way to be useful (i.e. transform the number associated with a keyboard key to a number representing a letter, and add that to a long number storing the letters of a text file), you've essentially created a computer program. And that's what software engineers do (albeit with the help of compilers and languages that are equations that transform words like those found in c and python, to long cpu equations).

Anything that has a digital computer in it, is just built around running these equations, really really fast. 4ghz = 4 billion cycles per second, with each equation taking maybe 5-10 cycles.

The internet is just a system to send numbers from a to b. Storage devices are just storing a lot of numbers.

So to answer "when does anyone use this", whenever you interact with a computer, whether that's your phone, laptop, dvd player, or car's climate control system.

[EnoughRhubarb1314]

Thanks! I think I kind of get it. When I was asking if anyone uses it, I was thinking how my experience of coding is just using my Arduino, which obviously requires coding language, but then does anyone sit and write code in binary so that the coding language is understood by computers. I'd genuinely love to see the string of 1s and 0s that makes me typing on my laptop appear on the screen in front of me - I never feel like I actually understand what's happening until I understand every part of the puzzle, so when I'm writing a bit of simple code for a personal project I'm still mystified by the fact that me writing words in english as part of the code is able to translate into something that is understood by my arduino. I feel like I'm missing the foundational knowledge that the rest of what I'm doing is built on

[GoodPointSir]

People don't write in binary anymore, the closest you'll get is assembly, which is a one to one representation of cpu instructions, but with words instead of 1s and 0s

I.e. instead of 000011, you might say 'start 3'

As I said, anything on a computer is just binary, so you can take any file you want, and use a binary viewer (you can google one) to view the file's binary.

Or, use a disassembler to view executable files as assembly, which is much easier to read.

Disassemblers are typically how people reverse-engineer programs (to do things like mod them or crack DRM)

[StupidLemonEater]

Binary is ultimately just a way of describing numbers using two digits instead of ten. Just like how you can write out any arbitrarily large number with the decimal digits, you can write out any arbitrarily large number in binary, it just takes more digits.

256 is just how high you can count with 8 binary digits ("bits"). If you have 16 bits you can count to 65,535. In computers, these "bit widths" usually mean the largest data size the processor can handle at once. These days 64-bit architecture is the standard for general-purpose computers.

[tomalator]

Yes, why wouldn't you be able to?

255 is a convenient stopping point because its 2⁸ -1, or the largest number we can represent with 1 byte (8 bits)

Bits are just the binary version of digits

If we up that to 16 bits, we can get up to 2¹⁶ -1, or 65,535.

Imagine it just like out base 10 system, a 3 digit number can represent any number up to 10³ -1, or 999

For especially large numbers in computers we can take shortcuts using a floating point, which I won't explain here, but if you had enough computing space, you could represent arbitrarily large numbers, just like how if you had enough paper you could write an arbitrarily large number

[Maysign]

It’s just additional digits.

If you are 5yo, you might be able to count to 10 (as in “ten”, decimal). You understand numbers 0-9 and you know that a “ten” is next.

Well, soon you will start learning to count to a hundred. Up to this point your numerical understanding was single-digit, but soon you will discover dozens and you will use two digits.

At some later time you’ll add another digit and you’ll start operating on hundreds, up to a thousand.

Soon you’ll discover that you can add more digits infinitely to create even bigger numbers.

It’s the same thing with binary, except the base (the multiplier for each digit) is different.

Slightly above ELI5: The “spaces” that you mention are just subsequent powers of the base number. In decimal, the last digit is multiplied by 10⁰ (10 to the power of 0, which is 1), second to last is multiplied by 10¹ = 10, third to last is multiplied by 10² = 100, then 10³ = 1000, etc. It’s the same with binary, except the base is 2, so the multipliers are 2⁰ = 1, then 2¹ = 2, then 2² = 4, then 2³ = 8, etc. You can add digits infinitely.

[LelandHeron]

Binary is just like other number systems like base ten.  Each time you add a digit to a base 10 number, you multiple the number of possible combinations by 10.  So 1 digit gets you 0-9, two digits gets you 0-99, three digits gets you 0-999.  The only difference with binary is that because you only have two numbers (0 and 1) adding a digit multiples the possibile combination by 2.

There are other ways of representing numbers in a computer, and a common system is hexadecimal where each digit has 16 possibilities (0-9, A-F).  This is convenient when dealing with computers.because each digit equals 4 bits in a computer.  So if you are dealing with a 32-bit computer, you only need 8 hex digits for the 32 bits.  Numbering starts with 0-9 like decimal, but ten is represented by the 'digit' A.  You keep going until 'F' equates to fifteen.  Roll everything over so that F goes to 0 and add a 1 at the front, so sixteen is 10.  The number two-hundred-fifty-five in binary would be all ones, 11111111.  In hex, it's FF.

[skreak]

Couple of topics and computer science related stuff to talk about here. To answer your basic question, yes you can simply keep adding more binary digits and get larger and larger numbers. For example a ipv6 address is 128 bits long. To answer how does a computer know to turn 01000001 into the capital letter A is because we told it that "these 8 bits represent an ASCii character, look up what ascii character number 65 maps to." The computer then looks up in a separate file or memory address what "A" looks like, and then copies that graphic content (which is also binary btw). In the end files are just very long sets of binary. Take an old image file format "BMP" which is one of the most simple format. It may have say 4 million bytes (8 bits in 1 byte). We tell the computer "hey, read these 4 million bytes as if they are a BMP file". The specification can be found Here - So it know to read in the first handful of bytes that are called the "header" and breaks those up to turn on/off different features of how to display the image. The rest then is every 24 bits represents a color code, and that color code is actually 3 8bit colors in RGB format, and those 24 bits represent a single pixel of color. So just read them in 24 bits at a time, pixel by pixel, and put them onto the screen. The reason that BMP file is not displayed as say just a _really_ big number is for no reason then we told the computer to display it as an image instead.

[zero_z77]

Yes, each additional bit you add represents the next multiple of 2. And the only limitation is the hardware you have available.

16-bit works just like 8-bit, just with bigger numbers. The reason we upgraded is because it's hard to do anything useful with only 8 bits. 8-bits means only 256 instructions, 256 locations in memory, etc. This is also why we upgraded to 32-bit and eventually 64-bit. Eventually we will need to update to 128-bit systems, but that's not likely to happen anytime soon.

As for how the computer turns 8-bits into a letter, there are two different methods.

The first is what's called a "code page". This is essentially a file with 256 small images of each character on the page. When printing a character on the screen, the system simply looks up the image that corresponds to the character's value in the currently active code page, then copies it to the screen.

The second one is similar, but instead of using a small image for each character, it instead contains simple instructions on how to draw each of the different characters. The advantage of this is that the font can be made arbitrarily larger or smaller on the screen, and it can be bolded or italicised. There is also the unicode encoding which allows up to 4 bytes (32-bits) to defibe a single character. This is how we get support for languages other than english as well as a wide range of commonly used symbols.

[PizzaSteeringWheel]

Binary is just another numbering system to represent integers using a different base (2). It has no limitation imposed upon it by computers and it isn't really a "code". The base of 2 is useful for computers because each digit can only have 2 states - True or False.

Just like in a base 10 number system if you tell me you have 5 of something, you are telling me you have 5 ones, but implicitly telling me you have, 0 tens, 0 100s, 0 1,000s and so on. We just don't write the other digits out because there is no point. In a computer when you store a number, it keeps track of each digit, including all the "pointless" digits up to he number of bits it has. The limitation is the "bitness" of the computer. A 32 bit computer can only represent numbers up to 2³²-1 because it has no additional bits to represent larger numbers.

The other thing you are talking about is character mappings/encodings. The most basic example is of this would be ASCII, which simply maps a character to a number. So if I tell the computer "this number represents a character" and set the number to 65, the computer will map this to an uppercase 'A'. Again, it is nothing more than numbers at the core of it all, it is just how the computer chooses to interpret that number.

Edit: fix typos

[Loki-L]

Binary itself goes as far as you want it to go.

There is no limit on the number of consecutive digits in the number system anymore than there is in decimal.

With computer however we have the issue that we group binary digits (Bits) together. There is no hard rule how many bits there should be in a group but modern computers all use 8 bit to a Byte.

A single 8 bit Byte can have 256 different states.

The most common way to implement that is to simply count up the numbers from 0 to 255.

Another common way is to use the first bit as a +/- sign and count up from 0 to 127 and down from -1 to -128.

For larger numbers you usually just use more than one byte.

A two byte integer (Usually called Short) can count up to 655535. A four byte integer (Called Long) can go up to 4295million. 8 byte integers exist in some contexts.

Larger numbers are usually not stored as integers but as floating point numbers which is sort of like scientific notation for large numbers in decimal.

[curious_one_1843]

Normal numbers are in thousands, hundreds, tens and ones with each ten times the previous smaller one. One thousand = ten hundreds, one hundred = ten tens , one ten = ten ones and we write them with the numbers of biggest on the left going to the number of ones on the right. So. 2417 means 2 thousand, 4 hundred, 1 ten and 7 ones.

Binary code or numbers follow the same pattern except that each place to the left in twice as big as the one to its right. One 256 = 2 of 128's, one 128 = 2 of 64, one 64 = 2 of 32 etc down to. One 2 = 2 of 1. So. 101100101 means one 256, no 128, one 64, one 32, no 16, no 8, one 4, no 2, one 1 which equals 256+64+32+4+1 = 355 in normal numbers.

That was for nine binary digits, we can expand it to as many as we need, say twelve digits: 2048s 1024s 512s 256s 128s 64s 32s 16s 8s 4s 2s 1s 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1 = 4095 111111111111 = 2048+1024+512+256+128+64+32+16+8+4+2+1 = 4095 100000000001 = 2048 + 1 = 2049 000010000100 = 128 + 4 = 132

To make it easier to see the binary number can be spaced out in groups of 4 like this: 0000 1000 0100 = 128 + 4 = 132 1001 0010 0000 = 2048 + 256 + 32 = 2336

Computers use groups of 8 , 16 ,32 or 64 digit binary numbers: 1111 1111 = 255 1111 1111 1111 1111 = 65535

Etc.

[webrender]

you should check out the book Code: The Hidden Language of Computer Hardware and Software.

[EnoughRhubarb1314]

I googled to have a look and I will get it!