Computer Programming (1)

administrivia

Web Page - http://www.cs.tau.ac.il/~efif/courses/ComputerProgramming

Hardware

components

Basic model

understanding computers

Understanding programming requires that you understand computers
How does a computer work?
- Idiot savant
- Very good with a small number of tasks
- Completely clueless otherwise

what can computers do well?

Store and retrieve numbers
- very quickly
- very accurately
Add, subtract, multiply, and divide
- also fast and accurate
Compare numbers (with 0)
Follow a list of instructions
- jump around in the list

that's about it

What about everything else?
- more complex math
  - combination of atomic operations
- interaction with peripheral devices
  - output: graphics cards and printers
  - input: keyboards, mice, joysticks
  - all sorts of specialized devices
- everything done using numbers

computer numbers

To the computer, everything is numbers.
Computers use binary (base 2)
- each digit is 0 or 1
- represents a power of 2

human numbers

You are familiar with decimal (base 10)

d_n d_n-1 d_n-2... d₂ d₁ d₀ =
d_n x 10ⁿ + d_n-1 x 10^n-1 + d_n-2 x 10^n-2 ... d₂ x 10² + d₁ x 10¹ + d₀ x 10⁰

38469 =
3 x 10 ⁴ + 8 x 10 ³ + 4 x 10 ² + 6 x 10 ¹ + 9 x 10 ⁰

binary

only two possible values for each digit

b_n b_n-1 b_n-2... b₂ b₁ b₀ =

b_n x 2ⁿ + b_n-1 x 2^n-1 + b_n-2 x 2^n-2 ... b₂ x 2² + b₁ x 2¹ + b₀ x 2⁰

10110110 =

1 x 2 ⁷ + 0 x 2 ⁶ + 1 x 2 ⁵ + 1 x 2 ⁴ + 0 x 2 ³ + 1 x 2 ² + 1 x 2 ¹ + 0 x 2 ⁰ =

1 x 128 + 0 x 64 + 1 x 32 + 1 x 16 + 0 x 8 + 1 x 4 + 1 x 2 + 0 x 1 =

128 + 32 + 16 + 4 + 2 =

182

terminology

bit: binary digit
byte: a group of 8 bits
nybble (obsolete): half a byte
word: a group of bytes that a specific computer is optimized for working with (usually 4 or 8)
kilobyte (K or KB): 1,000 bytes, or sometimes 1,024 bytes (2¹⁰)
megabyte (M or MB): 1,000,000 bytes, or sometimes 1,028,576 bytes (2²⁰)

why all these powers of 2?

Everything is little electronic switches
- off or on
- true or false
- yin or yang
- 0 or 1
Decimal is foreign to the computer
- it can convert a number to decimal, but that's really only for human convenience
The computer works in base 2

other numbering systems

octal – base 8

used rarely, but you should at least recognize it
digits are 0 through 7

o_n o_n-1 o_n-2... o₂ o₁ o₀ =
o_n x 8ⁿ + o_n-1 x 8^n-1 + o_n-2 x 8^n-2 ... o₂ x 8² + o₁ x 8¹ + o₀ x 8⁰

3264 =
3 x 8 ³ + 2 x 8 ² + 6 x 8 ¹ + 4 x 8 ⁰ =
3 x 512 + 2 x 64 + 6 x 8 + 4 x 1 =
1536 + 128 + 48 + 4 =
1716

hexadecimal – base 16

used occasionally – you can't really avoid it
digits are 0-9, a-f

h_n h_n-1 h_n-2... h₂ h₁ h₀ =
h_n x 16ⁿ + h_n-1 x 16^n-1 + h_n-2 x 16^n-2 ... h₂ x 16² + h₁ x 16¹ + h₀ x 16⁰

3b7e =
3 x 16 ³ + 11 x 16 ² + 7 x 16 ¹ + 14 x 16 ⁰ =
3 x 4096 + 11 x 256 + 7 x 16 + 14 x 1 =
12288 + 2816 + 112 + 14 =
15230

other numbering systems

You do not have to be fluent in either of these (octal or hex) for this class
- recognize them
- don't be scared of them
- know how to convert if you need to
  - but you will rarely need to

byte

A group of bits
- almost always 8
- some strange computers may have other byte size
  - but they are not an issue for this class
The fundamental unit of data for the computer
Can represent 256 values
- 0 to 255
- -128 to 127

word

Also fundamental to the computer
A group of bytes
- usually 4 or 8
- for the computers we will work with, it's 4
4 bytes
- 32 bits
- 0 to 4,294,967,295
  - or more usually, –2,147,483,648 to +2,147,483,647

inside the computer…

Everything is bits
Bits are always grouped
- into bytes
- into words
Every byte is numbered
- sequentially
- called an address
- addresses are, of course, numbers themselves

computer instructions

Computers execute instructions
Instructions are numbers
- memory access (get/put)
- arithmetic (add, subtract, multiply, divide)
- compare values (equal, greater than, less than)
- change the order instructions are executed in
  - often based on the result of a comparison

what kinds of numbers do computers work with?

Instructions
Addresses
Data
- integers
- real numbers
- text
- all sorts of other things

what is a computer program?

A sequence of processor instructions designed to achieve a specific purpose
- Computers execute programs sequentially
- Unlike, say, a shopping list
- More like driving directions
  - each instruction depends on the last one being completed
Each instruction has a numerical code
Examples:
- Get some data from memory
- Add two numbers
- If two numbers are equal, jump to a different part of the program
To us, it all just looks like numbers
Instructions are numbers
Random numbers can be executed
- but will not be a program
00401040 55 8B EC 83 EC 5C 53 56 57 6A 00 FF 15 B8 C2 42
00401050 00 89 45 FC 83 7D FC 00 7D 1B 68 0F 10 40 00 68
00401060 14 61 42 00 B9 E8 99 42 00 E8 32 05 00 00 8B C8
00401070 E8 90 FF FF FF 8D 45 EC 50 8B 0D 50 8D 42 00 51
00401080 FF 15 C0 C2 42 00 89 45 FC 83 7D FC 00 7D 20 68
00401090 0F 10 40 00 68 F8 60 42 00 B9 E8 99 42 00 E8 FD
004010A0 04 00 00 8B C8 E8 5B FF FF FF E9 9C 00 00 00 68
004010B0 0F 10 40 00 68 D8 60 42 00 B9 E8 99 42 00 E8 DD
004010C0 04 00 00 8B C8 E8 3B FF FF FF 8D 55 E4 52 68 28
004010D0 71 42 00 6A 01 6A 00 68 18 71 42 00 FF 15 C4 C2
004010E0 42 00 89 45 FC 83 7D FC 00 7C 1D 68 0F 10 40 00
004010F0 68 B4 60 42 00 B9 E8 99 42 00 E8 A1 04 00 00 8B
00401100 C8 E8 FF FE FF FF EB 43 8B 45 FC 50 68 88 60 42
00401110 00 E8 6A 25 00 00 83 C4 08 68 0F 10 40 00 68 84
00401120 60 42 00 8B 4D FC 51 68 60 60 42 00 B9 E8 99 42
00401130 00 E8 6A 04 00 00 8B C8 E8 33 01 00 00 8B C8 E8
00401140 5C 04 00 00 8B C8 E8 BA FE FF FF FF 15 BC C2 42

00401040 push ebp
00401041 mov ebp,esp
00401043 sub esp,5Ch
00401046 push ebx
00401047 push esi
00401048 push edi
00401049 push 0
0040104B call dword ptr [__imp__CoInitialize@4 (0042c2b8)]
00401051 mov dword ptr [ebp-4],eax
00401054 cmp dword ptr [ebp-4],0
00401058 jge main+35h (00401075)
0040105A push offset @ILT+10(endl) (0040100f)
0040105F push offset string "CoInitialize failed." (00426114)
00401064 mov ecx,offset cout (004299e8)
00401069 call ostream::operator<< (004015a0)
0040106E mov ecx,eax
00401070 call @ILT+0(ostream::operator<<) (00401005)
00401075 lea eax,[ebp-14h]
00401078 push eax
00401079 mov ecx,dword ptr [pid (00428d50)]
0040107F push ecx
00401080 call dword ptr [__imp__CLSIDFromProgID@8 (0042c2c0)]
00401086 mov dword ptr [ebp-4],eax
00401089 cmp dword ptr [ebp-4],0
0040108D jge main+6Fh (004010af)
0040108F push offset @ILT+10(endl) (0040100f)
00401094 push offset string "CLSIDFromProgID failed." (004260f8)
00401099 mov ecx,offset cout (004299e8)
0040109E call ostream::operator<< (004015a0)
004010A3 mov ecx,eax
004010A5 call @ILT+0(ostream::operator<<) (00401005)
004010AA jmp main+10Bh (0040114b)
004010AF push offset @ILT+10(endl) (0040100f)
004010B4 push offset string "CLSIDFromProgID succeeded." (004260d8)

machine language

The one “true” computer language
- …except there isn't just one
- Every computer has its own machine language
All other computer languages created for human convenience
- The computer doesn't understand C
- Must be converted into machine language

computer languages

Assembly

essentially just machine language with some text codes

Compiled languages

converted into machine language before use
examples: C, Pascal, Fortran

Interpreted languages

converted into machine language during use
examples: Basic, Perl, (Java)

most languages were designed with one or the other mechanism in mind

but there are interpreters for C, and there are compilers for BASIC

why more than one?

Meet different needs
Tradeoffs
Different approaches
Special features

meet different needs

Application domain
- programmer prefers to think about the application
Computer domain
- programmer is willing to think about the computer

tradeoffs

Control
Ease-of-programming
Performance
Flexibility

different approaches

Procedural
Object-oriented

special features

There are lots of special-purpose languages
- video games
- robots
- artifical intelligence
- embedded systems
- etc.

programming computers

The trick
- figuring out how to get the computer to do what you want it to do
- combining basic atomic operations to do interesting things

things we might want to do

Useful programs
- presentation software (i.e., this program)
- text editor
- computer game
- web browser

computer operations

Remember theyre very basic
- get/set memory values
- simple arithmetic
- test values
- execute instructions

getting from operations to programs

This is it
- its not easy
- its not obvious
- you can usually do something many different ways
  - some ways are good
  - some suck

so what's with this driving thing?

Analogy: driving a car
- why do we drive cars?
  - transportation: get from here to there
  - fun: drive fast, look good
  - race: drive real fast, dont crash
- how do we drive a car?
  - do we just tell the car where we want to go?
    - only in science fiction novels
  - we have to control the car

car controls

What controls do we have?
- ignition key
- steering wheel
- gas pedal
- brake
- clutch
- shifter
- turn signals
- radio

car operations

So what kinds of operations can we perform?
- ignition key
  - turn car on
  - turn car off
- steering wheel
  - rotate steering wheel clockwise
  - rotate steering wheel counterclockwise
- gas pedal
  - depress gas pedal (%)
- brake
  - depress brake pedal (%)

car operations continued

What kinds of operations can we perform?
- clutch
  - depress clutch pedal (%)
- shifter
  - move up
  - move down
  - move left
  - move right
- turn signals
  - ignore them
  - signal right turn
  - signal left turn

and just a couple more

Those were all output operations
Input is important too
- your eyes
  - look
- your ears
  - loud pipes save lives

(yawn) so what's yer point?

There is no obvious relationship between car operations and what you want to do with a car
Likewise, there is no obvious relationship between computer instructions and what you want to do with a computer

lets go a little deeper into this analogy

Driving directions: how to get from point A to point B
Example: how did I just get here?
- from Ayalon north exit on Rokakh Boulevard (West)
- turn left at stop light
- turn right at first stop light towards the University
- enter the university through gate 14

directions?

None of those directions mentioned any car parts or operations!
Our brains interpret automatically
- also handle a lot of unmentioned tasks
This is where the analogy breaks down
- computers cant make assumptions
- computers cant interpolate (unless programmed explicitly to do so)
- computers cant make judgment calls

interpreting directions

Lets look at the first direction:
from Ayalon north exit on Rokakh Boulevard (West)
What does this really mean?
- assumes I know how to get onto 'Ayalon'
- stay in my lane
- go the speed limit
- use the brake as necessary
- flip other drivers the bird

but even these arent useful!

Stay in my lane
- what does that mean?
- how could we express this with numbers?
  - measure:
    - local average of lane direction
    - car velocity vector
  - compute:
    - difference between lane direction and car velocity vector
    - desired deflection of velocity vector
  - adjust steering wheel
    - feedback loop
      - magnitude of difference between current and desired direction
      - perceived centripetal force

stay in my lane

Instructions:
- repeat the following continuously:
  - get lane direction
  - get car direction
  - desired deflection = difference (lane direction, car direction)
  - desired steering wheel rotation = S * desired deflection
  - S (Steering constant) is a constant that is unique to my car and my driving style
  - turn wheel to desired rotation
  - if perceived g-force > Gmax, turn wheel back a bit

details

Computers are the ultimate detail-oriented things
- they need everything spelled out exactly
- they will follow instructions literally
- they will follow stupid instructions just as diligently as sensible ones

so where does C come in?

In our analogy, this is how things match up:

"to get places" to balance my checkbook (or whatever)
car operations computer instructions
driving directions software design
instructions C program
So when you write a C program, you will be doing things in baby steps.

doesnt that get boring?

It sure can
- but there are ways to make things less tedious
In terms of the driving analogy
- in every step, you are regulating the cars speed
- that means that everywhere youre going to have the same set of instructions
  - adjust gas pedal and brake to make the current speed equal to the desired speed

functions

So, why not write the instructions generically once, and then invoke the same set of instructions from different places in the directions?
- this is the C concept of a function
- functions are groups of statements that can be invoked repeatedly
- functions can take parameters, which allow each invocation to be slightly different
  - such as the desired speed in the last example

so (finally!) lets talk about C

What is C?
- One of countless programming languages
  - but one of the more popular
  - was considered a "programmer's" language
- K&R C - the native UNIX form, known as either:
  - Bell Labs C, after the most popular compiler, or
  - K. &R. C, after the authors of the most popular textbook on the language
  - often called "Classic C"
- ANSI/ISO 9899-1990 (R1997) (American National Standards Institute)
  - ANSI-standard C
  - eliminating much uncertainty about the exact syntax
  - the main difference is in the grammar of the language
  - the form of function declarations has been changed making them rather more like Pascal procedures

a simple example

Simple Example - Power Point Show

Maintained by Efi Fogel. Last modified: October 29 2002.

"to get places"	to balance my checkbook (or whatever)
car operations	computer instructions
driving directions	software design
instructions	C program