Mental Model
COP-3223H

An intuitive starting point is a desktop calculator. You can perform one arithmetic operation at a time.

Example usage:

• 1 + 1
• 2 * 7
• 9 / 4

Add two multiplications: 2*2 + 3*3

We can improve ease of use by adding memory.

• store the number, e.g., 2 M+
• then recall twice and multiply, MR * MR
• store 2
• recall

2
store
clear
recall
*
recall
=

Use a calculator with a memory slot (m+, mr)

Use diagram with buttons that can be copied to show how they can be stored in memory slots.

Visually, if we could store the "buttons" (symbols for the buttons) in a list (more memory slots for instructions too), then make a machine that takes the symbols and uses them to press the buttons and automatically retrieve the next instruction, i.e., automate the user of the desktop calculator.

Imagine multiple memory slots (draw list of boxes)

Store multiple numbers, e.g., let's compute x^2 + y:

5
store x
3
store y

recall x
*
recall x
+
recall y

Draw instructions inside the memory boxes.

Number the instruction memory boxes.

fetch-decode-execute cycle (greatly simplified)

Have a little machine that steps through the program and

1. Fetches it from memory
2. Execute the instruction
3. Increment the program counter

Keep track of the current instruction, let's give it its own memory location, we'll label that location pc for program counter

Then this machine gets the instruction and inputs it to the calculator.

It reads each one then adds one to the program counter.

Now we have a stored program computer.

It can automatically fetch the next instruction.

After running a command we run something like this:

recall pc
+
1
=
store pc

This would need a separate working memory than the program to avoid conflicting with the program's working memory.

We can arbitrarily jump to any part of the program

recall 3
*
recall 3
*
recall 3
*
recall 3
*
recall 3
=

1: recall 3
2: *
3: goto 1

If we always repeat, we'll never end.

How can we repeat sometimes but not always?

1: recall x 2: if x=0 goto 1

1: 5
2: store e
3: 1
4: store result
----------------
5: recall result
6: *
7: 3
8: =
9: store result
10: recall e
11: -
12: 1
13: =
14: store e
15: if e>0 goto 5
-----------------------
16: recall result

On the calculator

• Input: the buttons
• Output: the display

How we represent it

• input a means read a number into memory location a
• output display the most recent number on the display

Example of squaring a given number:

input a
recall a
*
recall a
=
output

Von Neumann architecture

Desktop calculator with more memory and a program counter that automatically runs the next instruction.