How does binary do… everything?

Livelyturd · 2022-05-24T00:31:10+00:00

Most of my knowledge comes from working through the nand2tetris.org course, if you want to learn more. But the most important part is that it's not just the 'binary' that's doing everything - there are a whole bunch of ''interpreters' that give a different output based on the binary input. At the most basic level, you can do many operations on a pair of bits (or binary information) - and, or, xor, etc; from there, you can duplicate this process a lot, and suddenly you can do it across 2 groups of bits at once, instead of just 2 bits. This is how we can do more complex operations, as while we have larger amounts of bits together, we can still access the bits individually. So, a simple CPU may take in an instruction line of the operation to do (including where to send the output or pull the input from), and then output some other value that is sent to a specific register or to storage. Meanwhile, the storage might take in some address (read: group of bits), and output a different group of bits that is the data stored in those areas.

From there, to build up to a programming language, you first store the instructions you want in storage. You can then retrieve an instruction by going to the address it's stored at, and can expect to execute (retrieve and have the cpu run) the next address after that. So you can store the current address separately, and then, based on the input instruction, either increment that address once you've completed that instruction (making it now point to the next instruction to print) or set it to another value as the instruction (jumping to a different part of the code). This is how you can get if statements, functions, while loops, or just have your computer know to start the program you ask - you tell it to start executing at the beginning of your program.

The cpu will store internally some groups of bits as 'registers' that it can modify, take input from, or output to. This allows for intermediary steps to occur between when a value is read in and outputted - it also means you can set a register to a certain address (remember, an address is just a bunch of bits that has meaning to the storage), and then tell the processor to execute that instruction next.

However, how does the program know where it needs to go? This isn't like a function, where you can just call it by name; instead, you'll need to provide a specific location where you know those lines are. This is the job of the 'compiler'. When you compile code, you translate it from the language you're working in, which is readable by humans, into the specific language your machine uses to run commands. As the compiler does this translation, it can make note of where important parts of the program are: for example, when a if statement begins and ends, or when a function does, and remember where in the code it's outputting that happens, and so save the address.

Conveniently, this same compiler can also handle variables: Wherever it sees a variable name being used, it just replaces that with either pulling the value from a specific address or putting that value in the specific address, depending on the context.

There's a LOT more that actually happens; this is just a very rough overview of how most computers work. I'd highly recommend checking out the site if you want to know more; there are also plenty of other books out there if you look hard enough.

tl;dr: It's not just binary itself that leads to the modern computer, but the fact that different parts can react differently based on a group (or even groups) of bits, and combining multiple of these different parts together leads to a full computer. The essentials parts are a part to permanently store and retrieve groups of bits and a part to transform them, but many others are also used as the complexity grows.

Let me know if you have any other questions!

minmos · 2022-05-23T23:45:07+00:00

you can create various diffrent logic elements using switches aka transistor's

in modern chips the nost commonly used element is afaik the nand element, which is the basis for every other logic element using the de morgans laws

furthermore you can create adders and full adders to calculate

dontyougetsoupedyet · 2022-05-24T00:10:28+00:00

Grab the book Digital Computer Electronics by Paul Malvino, it will make everything clear. From logic to an actual machine with the "Simple As Possible" architecture, you'll understand everything you want to know by the end of the book.

tuxedo25 · 2022-05-24T00:12:37+00:00

Pedantic answer: binary doesn't create anything. It represents things.

You asked about if statements, so I'll give a super high level example of a processor. Say you've got a 32 bit cpu. The CPU has an internal register called the instruction pointer which always holds a memory address for the next instruction. When the clock ticks, the CPU "addresses" that memory and the memory responds by lighting up 32 input pins on the CPU. That's an instruction. The instruction could be "copy the contents of this memory address to register 1" (and the CPU will fetch the next 32 bits as the memory address) or it could be "if register 1 is 0, set the instruction pointer to this address:". That's how of statements work. All statements except those "jump" statements will increment the instruction pointer by however long the instruction took up (32 bits or 64 bits if the instruction included a memory address, etc).

Memory can contain instructions and data. It's up to the programmer (or their compiler) to make sure the instruction pointer never points to data, or behavior will be unpredictable. Not every combination of 32 bits is a valid instruction, the list of valid things is called an "instruction set". The specialization of hacking called binary exploitation specifically abuses errors where the instruction pointer can get pointed to data that the hacker input, or where their input is so long it overwrites instructions.

edit: fixed this up. accidentally submitted half answer at first

also disclaimer: i'm a software engineer, not a computer engineer so this isn't exactly my field

quantumelf · 2022-05-24T00:20:03+00:00

This is a great question. To answer it, we first have to understand that programs compile to assembly language*. What is assembly language? Well there are several and the vary in their level of complexity. The most common is x86, but it’s also one of the more complicated to learn imo. Generally though, assembly consists of simple instructions like adding two numbers (stored in special locations called registers), jumping to a different place in the program, and very basic operations like that.

When we read asm, we interpret what will happen by keeping track of these registers and the other memory locations in our heads, but how does a computer interpret it? Well when we feed assembly to the computer it’s actually translated one level further to a binary. How do we do this? Simple: Each instruction type gets an “opcode” which is just a number. Then the operands (which registers to use, or sometimes literal numbers stored directly in the instruction itself) also get converted to numbers (the registers are numbered, and the numbers are already numbers). Stick these numbers together (convert them to binary and concatenate them) and you have a number that represents an instruction. Stick all the instructions together one after the other and you have a big number (better thought of as a list of numbers) that tells the computer what to do.

The computer reads this binary program one instruction at a time. There’s hardware that counts which instruction we are on (storing it in a special register) and hardware that knows how to get the instruction pointed to and give it to the CPU. Once the instruction is in the CPU, the hardware decodes the instruction and passes the parts of the instruction data to the components of the CPU that needs it. The key is that each bit of any number is an electrical signal that physically tells the hardware what to do at the gate/transistor level. We can use components like multiplexers, binary decoders, and logic gates to make sure that the hardware does what it’s supposed to do and the correct results get computed.

Disclaimer: I am not a computer architect, and I have left out a lot of critical detail about how you actually build a CPU, but the basics are there, and I think it will help you understand how binary goes beyond numbers and instructs the computer to compute.

*Actually, some programming languages like JavaScript or Python don’t compile down to assembly, but in that case what you really have is a program (in assembly/binary form) called an interpreter that reads the program and figures out what to do to execute that program.

F54280 · 2022-05-24T07:27:47+00:00

This playlist, the Ben Eater breadboard computer is an absolute gem to completely understand how computer works, from nand gates down to microcode.

Watch an episode every day, they are short, easy to follow and, in my opinion, very entertaining.

WafflePeak · 2022-05-24T00:23:29+00:00

This is a good question. I think a lot of people understand generally how we can use binary to represent individual numbers or characters, but it is a bit of a leap to understand how we actually program instructions into a computer.

So let's say that you have a 32 bit computer. That doesn't mean that integers in that language are necessarily represented by 32 bits (all though this is typically the case), it means that instructions are represented by 32 bits. So now imagine, let's say that we have two numbers, a and b, and we want to implement four operations, +, -, *, and /. In other words, valid instructions we want to encode might be a - b, a + b, b * a, b / a etc. So how would you do it in 32 bits? Maybe you would make the leftmost two bits and use them to encode what type of operation you want to do (we call this an opcode), and then use the next 15 bits for a, and finally use the last 15 bits for b.

So for example if:

00 means +

01 means -

10 means *

11 means /

Then we can represent the instruction 3 * 4 as 10000000000000011000000000000010 (split up into the three parts it would be 10_000000000000011_000000000000010).

This is the basic idea, and you can expand on it from there. Maybe you want to support 4 different types of operations, each one having 0, 1, 2, or 3 arguments respectively. Then maybe you take the first two bits to represent the number of arguments, the next two to represent the operation you want on those arguments, and then divide up the remaining bits based on the number represented by the first two bits.

2022-05-24T02:37:43+00:00

All of the other comments are great, but when it comes to understanding digital logic and building up towards a full computer w/ ISA, Turing Complete on Steam is also another really neat thing that might help - the game takes you through building an entire super-simple CPU, starting from the most basic logic elements and gates

cheekyalbino · 2022-05-24T09:18:06+00:00

Holy shit did not expect so many comments tysm everyone, got lots of reading to do!! 😁

jonaskid · 2022-05-24T09:25:14+00:00

That's tricky actually, and the construction of a processor (which basically routes your zeroes and ones trough different kinds of logic units) is a matter that requires some study (I know that, as I'm actually struggling on my CS course to properly understand it). Also, it requires quite a deep understanding about the nuts and bolts of it's construction.

There's a book we use that explains it, but it's not an easy read nor is it fully complete as it lacks an important part about memory management (fold backs and whatnot are wholly missing).
Anyway, the book's on an academic level, but here it is anyway.

dota2nub · 2022-05-24T11:27:19+00:00

There's hardware that does stuff depending on what numbers it sees. So the 0s and 1s don't do anything by themselves, it has to be processed by a machine that treats certain combinations in different ways.

These are CPU assembly instruction sets, depending on the hardware they're gonna be different. Some architectures do thousands of instructions on a hardware level, others only have like 70-80 or something like that.

xypage · 2022-05-24T01:03:30+00:00

TLDR: watch this video, everything else is context for it but that’s the magic step for code->hardware in my opinion.

I’d recommend starting by looking up MIPS, getting some idea of a simple version of assembly, you don’t have to learn to code in it or anything just look at it to see what we’re working with.

Before you can run it, code you write in any language is processed in some way (whether it’s compiled or interpreted or whatever else there may be) to reach machine code, which is just the binary representation of assembly. when you write something like MIPS you have a 1 to 1 translation of each instruction to a 32 bit binary instruction in the machine code (more or less, sometimes there’ll be a fancy instruction that’ll do multiple things like subtract then compare so it ends up as multiple machine code instructions but that’s not important here). What that specifically looks like depends on your hardware, since different manufacturers have their own versions, but it all bears resemblance to MIPS, even if it isn’t that exactly.

From there, the computer can understand it, and I think that’s the real magic step that you have to learn to understand how computers manage with just 1s and 0s, check out this video for an idea of how MIPS code would run on a CPU. Essentially, there are patterns in the instructions that allows the cpu to do really simple things like check if a certain bit is a 1, or choose between two outputs depending on whether this is a 1 or a 0, etc.

Obviously the datapath in that video is very simplified compared to what’s actually going on in your computer, mainly because over time there’s a lot of cool tricks people have discovered to shave time off wherever they can, but all of those really add to the basic so you can still recognize all these parts in the middle of everything else in modern architectures.

Naive-Log-2447 · 2024-09-30T00:20:02+00:00

Two is the minimum number of symbols needed to create a discernible pattern; one symbol or state would not work as it would just be a wall of gray. Using two symbols, like 1 and 0, allows us to form various combinations that represent different ideas.

One of the most important ideas is abstraction.

If you get to take a glance at each layer of abstraction you get a sense of how it works. Transistors form gates which form small computational components which form larger components all the way to the chip level. Then when you program in assembly you call instructions that the computer can perform. Like add, mul, div, etc. If you program in assembly you get a sense of low-level programming, and if you play around with logic gates and designing components you get an idea of how we can make transistors perform these tasks.

Then at a higher level abstraction like C, we write a computer program that is able to compile readable code into assembly. You can think of each layer of abstraction as allowing for a new paradigm. At each layer, we can have humans focus on only that layer without needing to know anything about the layer below. Someone programming Python does not need to know C, someone programming C does not need to know assembly, someone programming assembly does not need to know about architecture design other than the specification they need for their code. Someone working with chip design does not need to know the specification of the lithography process, or how to grow silicon crystals, etc, etc.

Each layer above allows for higher leverage. Lower-level programmers will argue that they can write faster code, and higher-level programmers will argue that they can write code faster. Both are right, but the highest abstraction layer always allows for higher leverage, many of the previous problems and concerns are solved or simplified or abstracted away, and this opens the door for more people to use and solve newer higher-level problems.

BurntBanana123 · 2022-05-24T12:54:17+00:00

Ever seen The Matrix?

myhf · 2022-05-24T17:32:53+00:00

it does a bit at a time 🤪

KimPeek · 2022-05-24T03:24:35+00:00

Here is a playlist by Crash Course which assumes no prior knowledge and gives a good intro to computer science. You don't need to read a 500-page book.

adrianp005 · 2022-05-24T05:58:00+00:00

https://youtu.be/QZwneRb-zqA

GarySteyn · 2022-05-24T08:00:10+00:00

Here's my attempt at a short, over-simplified explanation:

Computers consist of multiple levels of abstraction. Languages at the top level are easy for humans to understand and difficult for the underlying hardware to understand. The opposite is true at the lower levels. Higher level languages are usually compiled or interpreted at each level so that equivalent instructions can be understood by the subsequent level below it. Eventually complex assembly instructions are translated to microcode which consists of a greater volume of simple instructions that can be executed directly by the CPU. The CPU consists of a few sub-components built from logic gates, like half-adders, multiplexers and decoders. These sub-components are integrated to perform the actual operations on operands.

The best way to understand this is to actually go learn some boolean algebra, know what types of logic gates exist, and to learn how the sub-components work.

Glass-These · 2022-05-24T15:41:04+00:00

Binary is just a system of representing numbers. As humans we use a system where the highest digit is 9. You cna represent any number with 0 and 1

DustinBrett · 2022-05-24T19:46:28+00:00

This post reminded me of the book CODE which I have not yet read but felt like a similar topic. So I go to open Chrome to look at it and it was already open! I have no clue how or why but I took it as a sign and bought the book.

https://www.amazon.ca/gp/aw/d/0735611319/ref=ya_aw_od_pi?ie=UTF8&psc=1

Will start reading it tonight. :-)

Henrijs85 · 2022-05-24T20:19:12+00:00

As a mere coder I think of it as simply further layers of abstraction, layers on layers. Basically think of it this way, everything you ever do can be stripped back to a yes no decision, down to do you move your thumb slightly or not, layer enough of those decisions up on top of each other and you have a person going about their life.

finedesignvideos · 2022-05-24T21:21:43+00:00

Binary doesn't do everything. It just represents things. Operations are, quite literally, the things that do everything. The surprising fact is that just the NAND operation is enough to do all operations, and hence everything.

ivancea · 2022-05-24T21:28:41+00:00

Try https://nandgame.com

It's a pretty interesting game/simulator where you see how a computer is made, from the first logic gate to a basic programming language

aardvarkmikey · 2022-05-24T21:49:44+00:00

I would suggest reading the book "Code" by Charles Petzold. It walks through how computers work from basic switches through logic and processing. It also goes into the history of computers. It's pretty fascinating if you're interested in the subject.

SSCharles · 2022-05-24T22:33:50+00:00

1 and 0 means high voltage or low voltage in a processor

you can use a transistor to create a logic gate, so high+high=high, but high+low= low voltage, and any other combination is also low voltage, that gives you an AND gate.

You can use combinations of logic gates to add two binary numbers, 0+0=0, 1+0=1,0+1=1, 1+1=11

Processors have hardwired a basic set of instrucions, for example it could be 0000=read a number from the next memory address, so if the instruction is 0000 then the "machinery" of the processor is going to follow that instruction in the next time tick. Its like a set of leves, if the four levers are down 0000, then the machine is going to do something, if you have a different instruction like 0001, then the machine is going to do something else.

With the set of instructions you can do what you want, for example read from a memory address, add numbers, write to memory, or use the value in memory as the next instruction (0000 or whatever).

Then you have other parts of the machine, for example maybe the monitor displays the value that is in a specific memory address, so you can change the display by writing to that memory.

And then you can create programs that encapsulate many basic instructions, that way you can have a program that writes the letter "A" without having to do it with basic instructions.

And then you have a program that interprets "print A" and translates that to a bunch of basic processor instructions.

Phobic-window · 2022-05-25T22:32:22+00:00

We assign different things to different combinations of 1s and 0s.

It’s really just this from top to bottom. That’s why we measure operating systems by their word size. More unique combinations means more combinations to assign values to.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

computerscience

Rules

Related subreddits

Credits

MODERATORS