CSC 270 - Survey of Programming Languages: Scheme (Racket)

Processing Simple Forms of Data

A few preliminary definitions

• Program - A set of instructions that tell the computer how to perform a task
• Programming - Writing a program
• Programming language - a language of instruction for a computer program
• Data - Information that is used by a program
• Operations - The individual instructions performed by the computer
• Primitive operations - The basic operations performed on data of a specific data type.
• e.g., +, -, * / are primitive operations performed on integers.
• Scheme - The programming language that we will use.
• Dr. Scheme - the program that we will use to run programs written in Scheme.

Numbers and Arithmetic

Computers were originally used as number crunchers (to perform complex, large-scale calculations). We now use them for many other purposes as well.

Numbers - can be positive or negative, rational (or fractions) or approximations of real values.

E.g., 5 -5 17/3 2/3 #i1.4142135623731

Scheme allows us to do arithmetic with numbers
(+5 5) (+ -5 5) (+ 5 -5) (- 5 5) (*3 4) (/8 12)

Simple Expressions

We can nest simple expressions in other expressions:

e.g.,
(+ 4 (* 2 7)) = (+ 4 14) = 18
(* 12 (+ 40 (*1.5 (- 46 40 )))) = (* 12 (+ 40 (* 1.5 6)))
= (* 12 (+ 40 9)) = (* 12 49) = 588

(* (+ 2 2) (/ (* (+ 3 5) (/ 30 10)) 2))
= (* 4 (/ (* 8 3) 2))
= (* 4 (/ 24 2))
= (* 4 12)
= 48

• Every expression in Scheme has the form
  (operation A B ....)
  where A, B and so on are the values
• Scheme uses prefix or Polish notation, where the operation is listed before the values being operated upon. Which is easier to learn:

  (+3 (* 4 5)) 	or 	3 + 4*5

• Scheme includes a whole range of mathematical operations including:

(sqrt A)		-	square root of A
(expt A B)		-	AB
(remainder A B)		-	Remainder from A/B
(log A)			-	natural logarithm of A
(sin A)			-	sine of A radians
					( 180 degrees = PI radians)

Variables and Programs

A variable is a placeholder in an expression that stands for some fixed unknown quantity, .e.g, 3.14 * r * r

r can be used to represent any positive number. If we find a value for it, (such as 5), we can evalueate the expression:

3.14* 52 = 3.15*25 = 78.5

Such expression state a rule that shows us how to calculate a certain value. A program is an example of such a rule.

Scheme Programs

We could write this as a Scheme program:

(define (area-of-disk r)
	(* 3.14 (* r r)))

This defines the funciton area-of-disk. We can now use (area-of-disk 5) to calculate a disk with a radius of 5:

(area-of-disk 5)
	=	(* 3.14 (* 5 5))
	=	(* 3.14 25)
	= 78.5 

Designing a new program

If we wanted to calculate the area of a ring, we would need the outer and inner radii and the ring's area would be:

(define (area-of-ring outer-radius inner-radius)
	(- (area-of-disk outer-radius)
	   (area-of-disk inner-radius)))

(area-of-ring 5 3)
	= (- (area-of-disk 5) (area-of-disk 3))
	= (- (* 3.14 (* 5 5)) (* 3.14 (* 3 3)))
	= (- (* 3.14 25) (* 3.14 9))
	= .....

Errors

There are three main types of errors that can be made in a program (whether in Scheme or another language):

• Syntax errors - expressions are not correctly written.

  	(define (P x) (+ (x) 10))
  	(define (P x)  x 10)
  	defin (P x) (+ x 10))

• Run-time errors - while evaluating an expression, Dr. Scheme encounters something that cannot be evaluated correctly

  	e.g., (/ 1 0)

• Logical errors - a program calculates the wrong result because the reasoning (or logic) of the program is flawed

  	(define (average2 x y) (* 2 (+ x y)))

Word Problems

Programmers are usually given word problems and not mathematical expressions to solve. Sometimes the description is ambiguous and may contain irrelevant information. The first job is to extract the important information from the description.

Company XYZ & Co. pays all its employees $12 per hours. An employee may work between 20 and 65 hours per week. Develop a program to determine an employee's gross pay.

The last sentence tells us that the goal is to find the gross pay.

We know that gross = Rate * Hours or 12*h in this case.

Our Scheme program becomes:

	(define	(wage h)
		(* 12 h))

The 20 to 65 hour work week seems irrevelant. We will discover late how to make use of it.

Composing Programs

When we wrote ring-area, we used our definiton of disk-area which we had already written.

We could have written:

(define (ring-area outer inner)
	( - (* 3.14 (* outer outer))
	( - (* 3.14 (* inner inner)))

instead of

(define (ring-area outer inner)
	( - (disk-area outer)
	( - (disk-area inner))

Does this form offer an advantage?

Another example

Every additional attendee cost more that he has to pay to the movie distributor. He pays $1.60 per attendee for an attendance 120, which increases (or decreases) by 4 cents per person) as attendances goes up (or down).

	Profit = Revenue - Cost
	Revenue = ticket price * attendance
	Cost = 1.6*Attendees + (.04*(Attendees-120)
	Attendance = (15/.10) * (5.00 - p) + 120

At what ticket price does he maximize his profit?

Our program becomes

(define (profit price)
	(- (revenue (attendance price) price)
		(cost (attendance price))))
(define (revenue (attendees price)
	(* attendees price))
(define (attendance price)
	(+ (* (/15 .10) (- 5.00 price))
		120))
(define (cost attendees)
	(+ (* attendees 1.6)
	(* 0.04 (- attendees 120))))

Compare this to:

	(define (profit price)
	(- (*(+(/ 15 .10)
		(- 5.00 price)) 120)  price)
	(+ (* (+ (* (/ 15 .10)
		(- 5.00 price)) 120)  price)  1.6)
	(* 0.04 (- (+ (* (/ 15 .10)
		-5.00 price)) 120)	120)))))

Which is clearer?

Guideline: Formulate auxiliary "programs" if a program's definition requires a large expression.

Variable definitions

When a number appears repeatedly, it makes enormous sense to give a name and use it by name. Pi is an obvious example

(define PI 3.14) or
(define PI 3.14159265)

Designing programs

Developing programs requires several steps:

• Understanding the program's purpose
• Program examples
• Writing the program body
• Testing
• Future reuse

Understanding the program's purpose

• A program consumes input and produces output. Therefore, we first give the program a meaningful name and write out the data produced and consumed. This is called a contract.
• We write the contract as:

  ;; ring-area : number number --> number

  • The ;; makes this a comment which is ignored by the computer.
• Next we write the header which describes the name of the program and its parameters (the data that it receives)

  (define (ring-area outer inner) ....)

• We also formulate a puropse statement for the program, explaining what it is computing:

  ;; ring-area number number --> number
  ;; to compute the ara of a ring whose radius is outer 
  ;; and whose hole has a radius of  inner
  ;; example (ring-area 5 3) = 50.24
  define (ring-area outer inner)

Program Body

In Scheme, the program body is a definition of the expression that we will compute.

• This requires an understanding of how the program computes the outputs from the given inputs.
• For our example, it becomes:

  (define (ring-area outer inner)
  	(- (disk-area outer)
  	  (disk-area inner)))

Testing

• After we have a completed program definition, we test it with data whose results we know to ensure that it works correctly.
• Adding an example in the program as a comment makes this easier.
• Testing cannot account for all possibler situations, but it can reveal syntax errors, run-time errors and most of the important logical errors.

Future Reuse

• The whole purpose of our design technique is to allow us to write it once and use it many times.
• We need to know what it does, but not necessarily how it does it in order to reuse it.

[Back to the Notes Index]