Chapter 14:

Topics in Computer Science: Speed

Big speed differences
Many of the techniques we’ve learned take no time at
all in other applications
Select a figure in Word.
It’s automatically inverted as fast as you can wipe.
Color changes in Photoshop happen as you change
the slider
Increase or decrease red? Play with it and see it happen
live.
Where does the speed go?
Is it that Photoshop is so fast?
Or that Python/Jython is so slow?
It’s some of both—it’s not a simple problem with an
obvious answer.
We’ll consider two issues:
How fast can computers get
What’s not computable, no matter how fast you go
What a computer really understands
Computers really do not understand Python, nor Java,
nor any other language.
The basic computer only understands one kind of
language: machine language.
Machine language consists of instructions to the
computer expressed in terms of values in bytes.
These instructions tell the computer to do very low-
level activities.
Machine language trips the right switches
The computer doesn’t really understand
machine language.
The computer is just a machine, with lots of
switches that make data flow this way or that
way.
Machine language is just a bunch of switch
settings that cause the computer to do a
bunch of other switch settings.
We interpret those switchings to be addition,
subtraction, loading, and storing.
 In the end, it’s all about encoding. A byte of
switches
Assembler and machine language
Machine language looks just like a bunch of numbers.
Assembler language is a set of words that corresponds
to the machine language.
It’s a one-to-one relationship.
A word of assembler equals one machine language
instruction, typically.
 (Often, just a single byte.)
Each kind of processor has its own machine
language
Older Apple computers
typically used CPU
(processor) chips called G3
or G4.
Computers running
Microsoft Windows use
Pentium-compatible
processors.
There are other processors
called Alpha, LSI-11, and on
and on.
Each processor understands only its own machine language
Assembler instructions
Assembler instructions tell the computer to do things
like:
Store numbers into particular memory locations or into
special locations (variables) in the computer.
Test numbers for equality, greater-than, or less-than.
Add numbers together, or subtract them.
An example assembly language program
LOAD #10,R0 ; Load special variable R0 with 10
LOAD #12,R1 ; Load special variable R1 with 12
SUM R0,R1 ; Add special variables R0 and R1
STOR R1,#45 ; Store the result into memory location
#45

Recall that we talked about memory as a long series of

mailboxes in a mailroom.
Each one has a number (like #45).
Assembler -> Machine
LOAD 10,R0 ; Load special variable R0 with 10
LOAD 12,R1 ; Load special variable R1 with 12
SUM R0,R1 ; Add special variables R0 and R1
STOR R1,#45 ; Store the result into memory location #45

Might appear in memory as just 12 bytes:

01 00 10
01 01 12
02 00 01
03 01 45
Another Example
 LOAD R1,#65536 ; Get a character from keyboard
 TEST R1,#13 ; Is it an ASCII 13 (Enter)?
 JUMPTRUE #32768 ; If true, go to another part of the
program
 CALL #16384 ; If false, call func. to process the new line

 Machine Language:
 05 01 255 255
 10 01 13
 20 127 255
 122 63 255
Devices are also just memory
A computer can interact with external devices (like
displays, microphones, and speakers) in lots of ways.
Easiest way to understand it (and is often the actual
way it’s implemented) is to think about external
devices as corresponding to a memory location.
 Store a 255 into location 65,542, and suddenly the red component of the
pixel at 101,345 on your screen is set to maximum intensity.
 Everytime the computer reads location 897,784, it’s a new sample just read
from the microphone.
So the simple loads and stores handle multimedia,
too.
Machine language is executed very quickly
Imagine a relatively slow computer today (not latest
generation) having a clock rate of 1.5 Gigahertz.
What that means exactly is hard to explain,
but let’s interpret it as processing 1.5 billion bytes per
second.
Those 12 bytes would execute inside the computer,
then, in 12/1,500,000,000th of a second!
Applications are typically compiled
Applications like Adobe Photoshop and Microsoft
Word are compiled.
This means that they execute in the computer as pure
machine language.
They execute at that level speed.
However, Python, Java, Scheme, and many other
languages are (in many cases) interpreted.
They execute at a slower speed.
Why? It’s the difference between translating
instructions and directly executing instructions.
An example
Consider this problem from the book:
Write a function doGraphics that will take a list as input. The function
doGraphics will start by creating a canvas from the 640x480.jpg file in the
mediasources folder. You will draw on the canvas according to the commands
in the input list.
Each element of the list will be a string. There will be two kinds of strings in
the list:
 "b 200 120" means to draw a black dot at x position 200 y position 120. The
numbers, of course, will change, but the command will always be a "b". You
can assume that the input numbers will always have three digits.
 "l 000 010 100 200" means to draw a line from position (0,10) to position
(100,200)
So an input list might look like: ["b 100 200","b 101 200","b 102 200","l 102 200
102 300"] (but have any number of elements).
A sample solution This program processes each
def doGraphics(mylist):
canvas = makePicture(getMediaPath("640x480.jpg"))
string in the command list.
for i in mylist: If the first character is “b”,
if i[0] == "b":
x = int(i[2:5])
then the x and y are pulled
y = int(i[6:9]) out, and a pixel is set to black.
print "Drawing pixel at ",x,":",y
setColor(getPixel(canvas, x,y),black)
If the first character is “l”, then
if i[0] =="l": the two coordinates are pulled
x1 = int(i[2:5]) out, and the line is drawn.
y1 = int(i[6:9])
x2 = int(i[10:13])
y2 = int(i[14:17])
print "Drawing line at",x1,y1,x2,y2
addLine(canvas, x1, y1, x2, y2)
return canvas
Running doGraphics()
>>> canvas=doGraphics(["b 100
200","b 101 200","b 102 200","l
102 200 102 300","l 102 300
200 300"])
Drawing pixel at 100 : 200
Drawing pixel at 101 : 200
Drawing pixel at 102 : 200
Drawing line at 102 200 102 300
Drawing line at 102 300 200 300
>>> show(canvas)
We’ve invented a new
language
["b 100 200","b 101 200","b 102 200","l 102 200 102
300","l 102 300 200 300"] is a program in a new
graphics programming language.
Postscript, PDF, Flash, and AutoCAD are not too
dissimilar from this.
There’s a language that, when interpreted, “draws” the
page, or the Flash animation, or the CAD drawing.
But it’s a slow language!
Would this run faster?
def doGraphics():
canvas = makePicture(getMediaPath("640x480.jpg"))
setColor(getPixel(canvas, 100,200),black)
setColor(getPixel(canvas, 101,200),black)
setColor(getPixel(canvas, 102,200),black)
addLine(canvas, 102,200,102,300)
addLine(canvas, 102,300,200,300)
show(canvas)
return canvas
Does the exact same thing
>>> doGraphics()
Which do you think will run faster?
def doGraphics(mylist): def doGraphics():
canvas = canvas = makePicture(getMediaPath("640x480.jpg"))
makePicture(getMediaPath("640x480.jpg") setColor(getPixel(canvas, 100,200),black)
) setColor(getPixel(canvas, 101,200),black)
for i in mylist: setColor(getPixel(canvas, 102,200),black)
if i[0] == "b": addLine(canvas, 102,200,102,300)
x = int(i[2:5]) addLine(canvas, 102,300,200,300)
y = int(i[6:9]) show(canvas)
print "Drawing pixel at ",x,":",y return canvas
setColor(getPixel(canvas, x,y),black)
if i[0] =="l":
x1 = int(i[2:5]) One just draws the picture.
y1 = int(i[6:9])
x2 = int(i[10:13]) The other one figures out (interprets)
y2 = int(i[14:17]) the picture, then draws it.
print "Drawing line at",x1,y1,x2,y2
addLine(canvas, x1, y1, x2, y2)
return canvas
Could we generate that second program?
What if we could write a function that:
Takes as input ["b 100 200","b 101 200","b 102 200","l 102
200 102 300","l 102 300 200 300"]
Writes a file that is the Python version of that program.
def doGraphics():
canvas = makePicture(getMediaPath("640x480.jpg"))
setColor(getPixel(canvas, 100,200),black)
setColor(getPixel(canvas, 101,200),black)
setColor(getPixel(canvas, 102,200),black)
addLine(canvas, 102,200,102,300)
addLine(canvas, 102,300,200,300)
show(canvas)
return canvas
 Introducing a
def makeGraphics(mylist):
file = open("graphics.py","wt")
file.write('def doGraphics():\n')
compiler
file.write(' canvas = makePicture(getMediaPath("640x480.jpg"))\n');
for i in mylist:
if i[0] == "b":
x = int(i[2:5])
y = int(i[6:9])
print "Drawing pixel at ",x,":",y
file.write(' setColor(getPixel(canvas, '+str(x)+','+str(y)+'),black)\n')
if i[0] =="l":
x1 = int(i[2:5])
y1 = int(i[6:9])
x2 = int(i[10:13])
y2 = int(i[14:17])
print "Drawing line at",x1,y1,x2,y2
file.write(' addLine(canvas, '+str(x1)+','+str(y1)+','+ str(x2)+','+str(y2)+')\n')
file.write(' show(canvas)\n')
file.write(' return canvas\n')
file.close()
Why do we write programs?
One reason we write programs is to be able to do the
same thing over-and-over again, without having to
rehash the same steps in Photoshop each time.
Which one leads to shorter time overall?
Interpreted version:
 10 times
 doGraphics(["b 100 200","b 101 200","b 102 200","l 102 200 102
300","l 102 300 200 300"]) involving interpretation and drawing
each time.
Compiled version
 1 time makeGraphics(["b 100 200","b 101 200","b 102 200","l 102 200 102
300","l 102 300 200 300"])
 Takes as much time (or more) as intepreting.
 But only once
 10 times running the very small graphics program.
Applications are compiled
Applications like Photoshop and Word are written in
languages like C or C++
These languages are then compiled down to machine
language.
That stuff that executes at a rate of 1.5 billion bytes per
second.
Jython programs are interpreted.
Actually, they’re interpreted twice!
Java programs typically don’t compile to machine
language.
Recall that every processor has its own machine
language.
How, then, can you create a program that runs on any
computer?
The people who invented Java also invented a make-
believe processor—a virtual machine.
It doesn’t exist anywhere.
Java compiles to run on the virtual machine
 The Java Virtual Machine (JVM)
What good is it to run only on a computer that
doesn’t exist?!?
Machine language is a very simple language.
A program that interprets the machine language of
some computer is not hard to write.
def VMinterpret(program):
for instruction in program:
if instruction == 1: #It's a load
...
if instruction == 2: #It's an add
...
Java runs on everything…
Everything that has a JVM on it!
Each computer that can execute Java has an
interpreter for the Java machine language.
That interpreter is usually compiled to machine
language, so it’s very fast.
Interpreting Java machine is pretty easy
Takes only a small program
Devices as small as wristwatches can run Java VM
interpreters.
What happens when you execute a Python
statement in JES
Your statement (like “show(canvas)”) is first compiled
to Java!
 Really! You’re actually running Java, even though you wrote Python!

Then, the Java is compiled into Java virtual machine

language.
 Sometimes appears as a .class or .jar file.

Then, the virtual machine language is interpreted by

the JVM program.
 Which executes as a machine language program (e.g., an .exe)
Is it any wonder that Python programs in JES are
slower?
Photoshop and Word simply execute.
As fast as 1.5 Ghz
Python programs in JES are compiled, then compiled,
then interpreted.
Three layers of software before you get down to the real
speed of the computer!
It only works at all because 1.5 billion is a REALLY big
number!
Why interpret?
For us, to have a command area.
 Compiled languages don’t typically have a command area
where you can print things and try out functions.
 Interpreted languages help the learner figure out what’s
going on.
For others, to maintain portability.
 Java can be compiled to machine language.
 In fact, some VMs will actually compile the virtual machine
language for you while running—no special compilation needed.
 But once you do that, the result can only run on one kind of
computer.
 The programs for Java (.jar files typically) can be moved from
any kind of computer to any other kind of computer and just
work.
More than one way to solve a
problem
There’s always more than one way to solve a problem.
You can walk to one place around the block, or by
taking a shortcut across a parking lot.
Some solutions are better than others.
How do you compare them?
Our programs (functions)
implement algorithms
Algorithms are descriptions of behavior for solving a
problem.
A program (functions for us) are executable
interpretations of algorithms.
The same algorithm can be implemented in many
different languages.
def half(filename): def copyBarbsFaceLarger():
source = makeSound(filename) # Set up the source and target pictures
target = makeSound(filename) barbf=getMediaPath("barbara.jpg")
barb = makePicture(barbf)
sourceIndex = 1 canvasf = getMediaPath("7inX95in.jpg")
for targetIndex in range(1, getLength( target) canvas = makePicture(canvasf)
+1): # Now, do the actual copying
setSampleValueAt( target, targetIndex, sourceX = 45
getSampleValueAt( source, for targetX in range(100,100+((200-45)*2)):
int(sourceIndex))) sourceY = 25
sourceIndex = sourceIndex + 0.5 for targetY in range(100,100+((200-25)*2)):
color = getColor(
play(target) getPixel(barb,int(sourceX),int(sourceY)))
return target setColor(getPixel(canvas,targetX,targetY), color)
sourceY = sourceY + 0.5
sourceX = sourceX + 0.5
show(barb)
show(canvas)
return canvas
Both of these functions implement a sampling
algorithm
Both of them do very similar things:
Get an index to a source
Get an index to a target
For all the elements that we want to process:
Copy an element from the source at the integer value of the
source index
to the target at the target index
This is a description of
Increment the source index by 1/2 the algorithm.
Return the target when completed
How do we compare algorithms?
There’s more than one way to sample.
How do we compare algorithms to say that one is faster
than another?
Computer scientists use something called Big-O
notation
It’s the order of magnitude of the algorithm
Big-O notation tries to ignore differences between
languages, even between compiled vs. interpreted,
and focus on the number of steps to be executed.
Which one of these is more complex in Big-O
notation?
def increaseRed(picture): def increaseVolume(sound):
for p in getPixels(picture): for sample in getSamples(sound):
value=getRed(p) value = getSample(sample)
setRed(p,value*1.2) setSample(sample,value * 2)

Neither – each one process each pixel

and sample once.
As the data increases in size, the amount
of time increases in the same way.
Spelling out the complexity
def increaseRed2(picture): def increaseVolume2(sound):
for x in range(1,getWidth(picture)): for sample in range(1,getLength(sound)):
value = getSampleValueAt(sound,sample)
for y in range(1,getHeight(picture)):
setSampleValueAt(sound,sample,value * 2)
px = getPixel(picture,x,y)
value = getRed(px)
setRed(px,value*1.1)

Call these bodies each (roughly) one step. Of course, it’s

more than one, but it’s a constant difference—it doesn’t
vary depending on the size of the input.
Does it make sense to clump the body as one
step?
Think about it as the sound length increases or the
size of the picture increases.
Does the body of the loop take any longer?
Not really
Then where does the time go? In the looping.
In applying the body of the loop to all those samples or
all those pictures.
Nested loops are multiplicative
def loops(): >>> loops()
count = 0 1 1 --Ran it 1 times
for x in range(1,5): 1 2 --Ran it 2 times
for y in range(1,3): 2 1 --Ran it 3 times
count = count + 1 2 2 --Ran it 4 times
print x,y,"--Ran it 3 1 --Ran it 5 times
",count,"times" 3 2 --Ran it 6 times
4 1 --Ran it 7 times
4 2 --Ran it 8 times
The complexity in Big-O
The code to increase the volume will execute it’s body
(the length) times.
 If we call that n, we say that’s order n or O(n)

The code to increase the red will execute it’s body (the
length)*(the height) times.
 That means that the body is executed O(l*h) times
 That explains why smaller pictures take less time to process than
larger ones.
 You’re processing fewer pixels in a smaller picture.
 But how do we compare the two programs?
 We would still call this O(n) because we address each pixel only once.
How about movie code?
def slowsunset(directory): def makeSunset(picture):
canvas = for x in range(1,getWidth(picture)):
makePicture(getMediaPath("beach- for y in range(1,getLength(picture)):
smaller.jpg")) #outside the loop!
p = getPixel(picture,x,y)
for frame in range(0,100): #99 frames
value=getBlue(p)
printNow("Frame number: "+str(frame))
setBlue(p,value*0.99) #Just 1% decrease!
makeSunset(canvas)
value=getGreen(p)
# Now, write out the frame
setGreen(p,value*0.99)
writeFrame(frame,directory,canvas)

The main function (slowsunset) only has a single

loop in it (for the frames), but the makeSunset
function has nested loops inside of it. But it’s still
processing each pixel once.
There are just lots of pixels!
Why is movie code so slow?
Why does it take longer to process movies than
pictures?
Because it’s not just the nested loops of pictures
It’s usually three loops.
One for the frames.
Two to process the pixels (like increaseRed2() )
It’s still O(n), but the n is big because it’s number of
frames times the height of each frame times the width
of each frame.
Sound vs. pictures vs. movies
Why isn’t sound code super-fast than?
We usually don’t have frames that are 22,000 pixels to a
side (the number of samples in one second of sound at
our lower resolution!)
The algorithmic complexity of all three, for the things
we’re doing, is the same.
We touch each pixel or sample only once, so it’s O(n)
Not all algorithms are the same complexity
There is a group of algorithms called sorting
algorithms that place things (numbers, names) in a
sequence.
Some of the sorting algorithms have complexity
around O(n2)
 If the list has 100 elements, it’ll take about 10,000 steps to sort them.

However, others have complexity O(n log n)

 The same list of 100 elements would take only 460 steps.

Think about the difference if you’re sorting your

10,000 customers…
Puzzle
You have six blocks.
One of them weighs
more; the other five
weight the same.
You have a scale, but you
can only use it twice.
Find the heaviest one.
 How do you do it?
Finding something in the dictionary
O(n) algorithm
Start from the beginning.
Check each page, until you find what you want.
Not very efficient
Best case: One step
Worse case: n steps where n = number of pages
Average case: n/2 steps
Implementing a linear search algorithm
def findInSortedList(something, alist): >>> findInSortedList ("bear",
for item in alist: ["apple","bear","cat","dog","elephant
"])
if item == something:
'Found it!'
return "Found it!"
>>> findInSortedList ("giraffe",
return "Not found"
["apple","bear","cat","dog","elephant
"])
'Not found'
A better search in a sorted list
O(log n) (log2 n = x where 2x=n)
 Split the dictionary in the middle.
 Is the word you’re at before or after the page you’re looking at?
 If after, look from the middle to the end.
 If before, look from the start to the middle.
 Keep repeating until done or until it couldn’t be there.

More efficient:
 Best case: It’s there first place you look.
 Average and worst case: log n steps
Implementing a binary search
def findInSortedList(something , alist ):
start = 0
While there’s anymore
end = len(alist) - 1 pages to search…
while start <= end: #While there are more to search
checkpoint = int(( start+end )/2.0)
if alist[checkpoint ]== something:
return "Found it!"
if alist[checkpoint]<something:
start=checkpoint +1
if alist[checkpoint]>something:
end=checkpoint -1
return "Not found"
printNow("Checking at: "+str(checkpoint )+"
Start:"+str(start )+" End:"+str(end))

Running the
>>> findInSortedList("giraffe" ,["apple","bear","cat",
"dog"])
Checking at: 1 Start :0 End:3
Checking at: 2 Start :2 End:3
Checking at: 3 Start :3 End:3 binary search
’Not found ’
>>> findInSortedList("apple" ,["apple","bear","cat",
"dog"])
Checking at: 1 Start :0 End:3
Checking at: 0 Start :0 End:0
’Found it!’
>>> findInSortedList("dog" ,["apple","bear","cat",
"dog"])
Checking at: 1 Start :0 End:3
Checking at: 2 Start :2 End:3
Checking at: 3 Start :3 End:3
’Found it!’
>>> findInSortedList("bear" ,["apple","bear","cat",
"dog"])
Checking at: 1 Start :0 End:3
’Found it!’
Thought Experiment:
Optimize your song
You’re writing a song that will be entirely generated
by computer by assembling portions of other sounds.
 Splicing one onto the end of the other.

You’ve got a bunch of bits of sound, say 60.

You want to try every combination of these 60 bits.
You want to find the combination that:
 Is less than 2 minutes 30 seconds (optimal radio time)
 And has the right amount of high and low volume sections (you’ve got a
checkSound() function to do that.)
How many combinations are there?
Let’s ignore order for right now.
Let’s say that you’ve got three sounds a, b, and c.
Your possible songs are: c, b, bc, a, ac, ab, abc
Try 2 and 4, and you’ll see the same pattern we saw
earlier with bits.
For n things, every combination of in-or-out is 2n.
If we ignore the empty combination, it’s 2n-1
Handling our 60 sounds
Therefore, our 60 sounds will result in 260
combinations to test against our desired time and our
time check
That’s 1,152,921,504,606,846,976 combinations.
Let’s imagine that we can test each one in only a
single byte (unbelievable, but pretend).
On a 1.5 Ghz laptop, that’s 768,614,336 seconds
Spelling it out
768,614,336 seconds is 12,810,238 minutes
 12,810,238 / 60 is 213,504 hours
 Divided by 24 is 8,896 days
 Which is 24 years

But since Moore’s Law doubles the processor speed

every 18 months, we’ll be able to cut that down to 12
years next year!
If we cared about order, too (abc vs. bca vs. cba…)
we’d have to multiply the number of combinations by
7 followed by 63 zeroes.
Optimization is a very complex
problem
Trying to find the optimum combination of a set of
things turns out to have so simple algorithm for it.
It always takes a very long time.
Other problems seem like they should be do-able, but
aren’t.
The Traveling Salesman Problem
Imagine that you’re a sales person, and you’re
responsible for a bunch of different clients.
Let’s say 30—half the size of our optimization problem.
To be efficient, you want to find the shortest path
that will let you visit each client exactly once, and not
more than once.
Being a smart graduate of this class, you decide to
write a program to do it.
The Traveling Salesman Problem currently can’t
be solved
The best known algorithm that gives an optimal
solution for the Traveling Salesman Problem is O(n!)
(That’s factorial)
 There are algorithms that are better that give close-to but not-guaranteed-
best paths
For 30 cities, the number of steps to be executed is
265,252,859,812,191,058,636,308,480,000,000 (30!)
The Traveling Salesman Problem is real.
 For example, several manufacturing problems actually become this
problem, e.g. moving a robot on a factory floor to process things in an
optimal order.
Class P, Intractable, and Class NP
Many problems (like sorting) can be solved with an
order of complexity that’s a polynomial, like O(n2)
 We call that Class P problems.

Other problems, like optimization, have known

solutions but are so hard and big that we know that
we just can’t solve them a reasonable amount of time
for even reasonable amounts of data.
 We call these intractable

Still other problems, like Traveling Salesman Problem

seem intractable, but maybe there’s a solution in Class
P that we just haven’t found yet.
 We call these class NP
Then there are impossible problems
There are some problems that are provably
impossible.
We know that no algorithm can ever be written to solve
this problem.
The most famous of these is the Halting Problem
Which is, essentially, to write a program to completely
understand and debug another program.
The Halting Problem
We’ve written programs that can read another
program and even write a new program.
Can we write a program that will input another
program (say, from a file) and tell us if the program
will ever stop or not?
 Think about while loops with some complex expression—will the
expression ever be false?
 Now think about nested while loops, all complex…

It’s been proven that such a program can never be

written.
Alan Turing
 Brilliant mathematician and
computer scientist.
 Came up with a mathematical
definition of what a computer
could do…before one was even
built!
 The Turing machine was
invented in answer to the
question of what the limits of
mathematics were: What is
computable by a function?
 He proved that the halting
problem had no solution in 1936
—almost ten years before the
first computers were built.
Why is Photoshop faster than Python?
First, Photoshop is compiled.
Compiled programs run faster than interpreted
programs.
Second, Photoshop is optimized.
Where things can be done smarter, Photoshop does it
smarter.
For example, finding colors to be replaced can be made
faster than the linear search that we used.
Can we write a program that thinks?
Are human beings computable?
Can human intelligence be captured in an algorithm?
Yes, we can debug programs, but there may be some
programs that are too complex for humans to debug—
we may fall under the Halting Problem, too.
Is it Class P? Class NP? Intractable?
Are humans just computers in flesh?
These are questions that artificial intelligence
researchers and philosophers study today.
What makes one computer faster
than another?
When your read an advertisement for a computer,
what does it mean?
What parts mean that the computer is fast?
Answer: Depends on what parts you will need to be
fast!
Clock rate is a drill sergeant
The clock yells “Go! Go! Go!” at a certain rate.
Faster “Go! Go! Go!” generally means faster execution,
within the same kind of processor.
Some processors more efficient per “Go!”
Dual core means that there are two sergeants, two
soldiers.
Can they do twice as much? If they work together well.
Quad core means four, and so on.
Storage types
Cache memory is the space at your desk.
You can get to it fastest. Most expensive.
RAM storage (SDRAM) is the main memory.
1 megabyte is 1 million characters of memory.
1 gigabyte is 1 billion characters.
Slower than cache, much faster than disk.
RAM disappears when the power is turned off
Hard disk is slowest memory but is permanent.
It’s where you store your files.
Storage relationships
If you have too little RAM, your computer will store
some things on hard disk.
It will be slower to bring back into RAM for the
computer to use it.
System bus describes how fast things can move
around your computer.
Network is even slower than hard disk.
If you’re grabbing a web page from the network, onto
the hard disk, and into RAM, the network speed will be
the limiting factor.