COMPUTER SCIENCE explained in 17 Minutes

Computers make no sense. Throw some metal in a box  and boom [monke]. What the heck is going on here? 

Inside your PC is a Central Processing Unit,  or CPU. It’s basically just a piece of silicon  

with billions of microscopic switches called  transistors. Depending on the flow of electricity,  

they can be on or off, kind of like a light  bulb, which gives us two states: 1 and 0. 

The value at one of these switches is called a  “bit”. One bit by itself doesn’t really do much.  

But put them together, and magic starts to happen. A group of 8 bits is called a “byte” and can  

have 256 different combinations of 0s and 1s.  Congratulations! We can now store information  

by counting in a system called “binary”. Every bit represents a power of 2,  

1 meaning the power is included and 0 meaning  it’s not, so this number has 1 times 64,  

1 times 4, and 1 times 1, which adds up to 69. This is nice, but for humans, hexadecimal is  

even better: It’s often denoted by this 0x and  is simply a more readable format than binary:  

Four binary bits can take any value from  0 to 15. Hexadecimal uses 0-9 and a-f  

to represent those values, so a group of four  bits can be replaced by one hexadecimal digit. 

Okay. Now that we can store numbers,  we just need computers to actually,  

you know, do something with them. Using transistors, you can make logic gates,  

which are electronic circuits that encapsulate  logical statements. You can think of it as a  

lightbulb with two switches, where the light  only turns on under certain conditions.  

For example, only if A AND B are on. By combining logic gates in a clever way,  

you can build circuits that perform calculations  according to Boolean algebra, which is a system  

formalizing mathematical operations in binary. But, even though computers understand 0s and 1s,  

for humans, it’s not really all that useful.  So, using a character encoding like ASCII,  

we can assign a binary number to each  character. When you type an A on your keyboard,  

it gets translated into this binary code, and as  soon as the computer sees this, it says: “Ah yes,  

that is a capital A.”, and slaps it on the screen. How these devices fit together is handled by an  

operating system kernel, like Windows, Linux or  Mac, which sits between computer hardware and  

applications and manages how they all work  together, for example with device drivers. 

Input devices allow you to give the computer  instructions with the press of a button,  

but at the lowest level, computers only  understand instructions in machine code,  

which is binary code telling the CPU  what to do, and which data to use. 

When it comes to following these instructions,  the CPU is kind of like a genius, just with the  

memory of a demented goldfish. It can handle  any instructions but it cannot store any data,  

so it’s only really useful with  random access memory or RAM. 

You can imagine it like a grid, where  every box can hold one byte of information,  

which can be data or instructions, and has an  address, so the CPU can access it in four steps: 

Fetch from memory, decode instructions  and data and finally, execute and store  

the result. This is one machine cycle. Since a program is basically just a list  

of instructions in memory, to run it,  the CPU executes them one by one in  

machine cycles until it’s complete. Oh yeah did  I mention that this happens, like, really fast? 

Modern CPUs can do billions of cycles every  second, which are coordinated and synchronized  

by a clock generator. The speed of this clock  is measured in GHz, and people often overclock  

their CPUs to improve performance, which is  nice, but might just set your PC on fire. 

What’s ever crazier though, is that a CPU has  multiple cores, which can all execute different  

instructions in parallel, so at the same time.  Each core can be split into multiple threads,  

which also allows every single core to  handle multiple instructions concurrently,  

so switch between them really quickly. Okay, that’s cool, but it doesn’t matter  

how powerful a computer is if you have no way  to give it instructions in the first place.  

Typing machine code by hand would probably make  you go insane, but luckily, you don’t have to: 

The kernel is wrapped in a shell, which is just  a program that exposes the kernel to the user,  

allowing for simple instructions in a  command line interface with text inputs. 

But the best way to make a computer do  something useful is with a programming language,  

which uses abstraction, so that instead of  this, you can write code that looks like this,