Right off the bat, I’m a bit confused with what this lecture is about.
It’s title is “Hardware 2″, so I’m guessing it’s a continuation of last week’s lecture, but the first point it makes is about representing data… Okay lets just go with this for now and see where it goes.
The computer can’t store letters, since it only has switches which can be on or off, so instead it stores bits (either an on or off switch). Eight of which make a byte. A word is the term for the number of bytes which an operating system works with best – ie. how many bytes it likes to group together and read and write to at the “same time”. Windows XP and earlier mostly use word sizes of 32-bits. The x84 edition of Windows XP and Vista both use 64-bit sized words. This slide mentions prefixes too, which I have no idea about.
Flicking through the presentation further, it looks like he didn’t actually mean the computer sciences term, but instead the term used to mean the collective terms for bytes; kilobyte, megabyte, etc.
Binary is base two. To explain that a little more, humans use base 10, which means our numbers can go from 0 to 9 before we have to move along to another digit. Binary can go from 0 to 1 before moving onto the next digit.
Hexidecimal is base 16, so it can go from 0 to F before having to move onto the next digit. Base is sometimes known as “radix”.
In order to represent letters, we designed a standardised code where a number relates to a letter. For instance, in ASCII the number 97 is the letter “a”. So if the computer wanted to store that letter, it’d hold the binary 11000001 in memory. ASCII is pretty out of date now though (still used in some places though because it’s really small to encode), these days we use Unicode or another ISO standard.
There’s a slide of real numbers next but to be honest I’m getting bored of this topic, so I’m skipping it.
A dude called Von Neumann thought up our hardware idea about 50 years ago; data is stored on more perminant, but slow to access mediums like hard drives, then it’s pulled out and any changes that need to be made should be done in volatile but super fast RAM. Once it’s in the RAM, it’s worked on by the processor.
When you run a program it’s pretty much the same too; each line of machine code is fetched from the hard drive to the RAM where it’s passed to the processor to work on. Machine code is rarely used by people unless they’re making dedicated systems, since it’s a minimalist language specific to the hardware being used. The language can be different from an Intel system than an AMD system, which is why programmers prefer to use high level languages which can be compiled to be compatible with other pieces of hardware.
Although they’re all different, they mostly do the same things. Either,
- A logic operation (do this is that’s true)
- Control transfer of information around the machine
- Load something
- Add to the input, or output devices
- Look up a memory location
- Or talk directly with the processor
I’ve already talked about slides 16, 17, and 18.
I talked about RAM quickly – say that it’s really fast, but volite memory. That means that when it loses power (the machine is turned off) it loses all the data it had on there. ROM on the other hand doesn’t lose it’s data, but it still incredibly speedy. The down side of it though is that it’s read-only, which means we can’t write to it. That may sound a little useless, but it actually holds fireware perminantly, and the BIOS controls.
(I’m ignoring that floating point slide.)
Originally, process had a limited set of commands and instructions, because they never really needed to be so complex back then, which we call Reduced Intstruction Set Computers. These days though, since the processor can handle low level languages much faster than any other type of higher language, the instruction set has been growing and growing. We now call it computers with large sets Complex Instruction Set Computers.
Of course, the fewer the instructions the processor has to look for, the faster it can compile the rest of the code. Reduced instructions sets are usually much faster than complex ones.
Making faster and faster processors quickly became too much of an investment for Intel and AMD (two of the largest processor producers), so they decided to switch to multiprocessing. That’s where two processors (or more) can work together to handle twice as much load as a single process on it’s own. Although the cores can “think” completely differently, they still share the same connection to the computer, are still on the same chip, and share the same cache.