Lecture 18

Imperative Programming

Logistics and Week Ahead

For some - Ethics Module 7 - Labor (if you're not signed up for an Ethics Discussion or missed yours earlier in the quarter you need to come see me ASAP)

• Monday - Intro to Imperative Programming
• Wednesday - More Imperatives (Pre-Recorded + MQ13) + Tutorial 7
• Friday - Scope (MQ 14) (Ex 6 Due)

Reminders / Announcements:

• Q2 Grades available by Wednesday
• Exercise 6 DOES NOT use imperatives and is in #lang htdp/isl+
• If you wish to work with a partner** on Ex6, follow the instructions on the assignment. Sign-ups will close Tuesday at 11:59pm for partners. IF YOU PLAN TO HAVE A PARTNER DO NOT SUBMIT PRIOR TO BOTH JOINING A CANVAS GROUP.

The story up until now

• Everything in your computer is data
• Including programs
• Data is divided into objects
• Objects can be inside other objects
• An album is made up of a title, artist, and genre
• Colors inside bitmaps
• Objects have types
• Procedures (Functions)
• Numbers (1 or -3.5)
• Strings (“this is a string”, “blue”)
• Picture/image objects (ellipses, rectangles, etc.)
• Albums, trees, lists, etc.

The story up until now

• Computation is performed using expressions
• Expressions have (or “return”) values (i.e. outputs)
• Computation is performed by recursively replacing expressions with their values
• A computation's only output is its return value
• It's return value only depends on:
• Its inputs
• The expression's structure
• The other definitions in the program
• It doesn't depend on what was computed before unless it's directly nested/chained/connected to it
• Once we define a variable, it's been impossible to update it

Change and effect

• But some expressions don't return values
• (define name value) causes a variable be defined
• (require module) causes a bunch of functions to become defined
• (define-struct type (properties…)) causes a new type be defined via some automatically defined functions.
• These are examples of expressions we run not because they return values
• But because they do things
• They change the computer

​

• These changes are called side effects, or just effects
• What it really means is some change caused by the expression

Calling functions for their effects

• You can write functions that make a wide range of changes in the computer
• Changing a variable's value (assignment)
• Changing a data object (mutation)
• Creating files
• Creating windows
• Performing input or output
• Commands that change the computer this way are called imperatives
• As with everything else in this class, complex effects
• Are ultimately built up from a few kinds of simple effects
• And methods for combining them

Imperative programming

Functional vs Imperative Programming

• Functional programming is programming without effects and sequencing
• The only effects (output) of an expression is its return value
• Value of a function call is determined entirely by the inputs to a function which might include nested function calls
• Result doesn't depend on order of execution of subexpressions; the substitution model perfectly emulates execution.
• Imperative programming
• Expressions can have many different effects: return value, changing variables, deleting files, etc.
• Those side effects can influence the behavior of other expressions (even if they seem unrelated).
• Computation is achieved by sequencing changes
• Forces us to think about execution as changes and causality

Advantages of imperative programming

• Imperative programs can be more efficient than functional programs
• Because the low-level hardware is ultimately representing the code as imperatives (you'll learn more about this in CS 213).
• Simpler for some application domains
• Simulations: what you're computing is just a series of changes (e.g. video games)
• Random numbers: if your random number generator always returns the same value…
• Other applications where the task definition involves change

#lang htdp/asl

All the code for the rest of the quarter will be in the Advanced Student Language with the exception of Ex.6

Effects in imperative programs

• An imperative might produce an output
• But it also has an effect on the computer
• i.e. changes memory
• Also known as a “side effect”
• It’s very important to make the effects of an imperative clear to a human reader
• Or you can get heinous bugs (in fact, this is one of key reasons we start with functional programming)

Effects in imperative programs

• So in addition to a
• Type signature
• Purpose statement
• We’ll also give one or more effect statements
• And we’ll also adopt a style convention that says that functions with side-effects are marked with a ! at the end of their names

;; make-window!: string -> window

;; Make a new window

;; Effect: creates a new window

;; on the screen

(define (make-window! title)

… some magic code …)

​

Types and Type Signatures in imperative programs

• It’s now possible to have functions that
• Take no inputs
• And/or generate no outputs
• So we need type signature notations for these

-> number�-> string

• Means a function that takes no inputs and returns a number, string, etc.

​

number -> void�string -> void

• Means a function that takes a number and returns no output

Primitive imperatives

The simplest possible imperative

; void : -> void�

(void)

• Sometimes, you need a function that literally does nothing
• No inputs
• No outputs
• No effects
• It’s just a placeholder.
• Most of the time, we use it to indicate a function returns no value and is instead being run for its side-effects

Assignment statements

(set! name new-value)

The next simplest imperative is assignment (set!) often read "set bang"

• After execution, the variable name is changed to have the value new-value
• Variable must have already been “created” using define
• This is a special form. It has no return value (i.e. (void))

Why is this different from define?

• You use define to make new variables
• Can't be used inside function definitions except…
• By putting it inside local to make new local variable
• It doesn't change the existing global variable
• You use set! to change an existing variable's value, be it a local or global variable, while the program is running
• Safe to use inside a function

Changing a global variable

(define count 0)

​

(define (increment!)

(set! count

(+ count 1)))

​

(define (clear!)

(set! count

0))

​

> count

0

​

> (increment!)

(void)

; means no value returned

​

> count

1

​

> (clear!)

(void)

​

> count

0

​

Composing imperatives

Composing imperatives

• Changes are most useful when we can chain them together
• So we need mechanisms for composing imperatives
• Do several imperatives in sequence
• Do imperatives repeatedly (looping)

Sequencing imperatives

Sequencing with begin

(begin expression-1 expression-2 …)

• Runs expressions in sequence
• Returns the value of the last expression automatically
• Equivalent of { }’s in Java, C++, etc.

Changing a global variable and returning a value

(define count 0)

​

(define (increment!)

(begin (set! count

(+ count 1))

count))

​

(define (clear!)

(begin (set! count

0)

count))

> count

0

> (increment!)

1

> count

1

> (clear!)

0

> count

0

​

Looping imperatives

Summing a list in imperative form

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

(sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! sum

(+ sum (first remaining)))

(set! remaining

(rest remaining))

(loop))))]

(loop)))

Imperative bugs

Imperatives can be tricky

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

​

​

Imperatives can be tricky

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

​

first: expects a non-empty list; given: '()

​

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

What happened?

(define (sum-list lst)

(local [(define sum 0)

(define remaining lst)

(define (loop)

(if (empty? remaining)

sum

(begin (set! remaining

(rest remaining))

(set! sum

(+ sum (first remaining)))

(loop))))]

(loop)))

​

(sum-list (list 1 2 3 4))

Higher-order imperatives

Looping as a sequencing primitive

• Most imperative languages have special iteration constructs
• while
• for
• foreach
• In ASL, you can just use functions
• for-each is a useful example

(for-each func a-list)

• Exactly like map in that it runs func repeatedly on the elements of a-list
• But returns no value so we use it when you’re calling func as an imperative

Cleaning up the code

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Example: (sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Example: (sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Example: (sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Example: (sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Example: (sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Example: (sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Example: (sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Example: (sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Example: (sum-list '(1 2 3 4))

(define (sum-list lst)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum (+ sum element)))

lst)

sum)))

Comparison of�functional and imperative programming

sum-list in functional and imperative form

Functional version:

​

(define (sum-list/func a-list)

(if (empty? a-list)

0

(+ (first a-list)

(sum-list/func

(rest a-list)))))

Imperative version:

​

(define (sum-list a-list)

(local [(define sum 0)

(define rem a-list)

(define (loop)

(if (empty? rem)

sum

(begin (set! sum

(+ sum

(first rem)))

(set! rem

(rest rem))

(loop))))]

(loop)))

​

sum-list in functional and imperative form

Functional version:

​

(define (sum-list/func a-list)

(if (empty? a-list)

0

(+ (first a-list)

(sum-list/func

(rest a-list)))))

Imperative version:

​

(define (sum-list a-list)

(local [(define sum 0)

(define rem a-list)

(define (loop)

(if (empty? rem)

sum

(begin (set! sum

(+ sum

(first rem)))

(set! rem

(rest rem))

(loop))))]

(loop)))

​

More focused on what to compute

More focused on how to compute it

sum-list in functional and imperative form

Functional version:

​

(define (sum-list/func a-list)

(if (empty? a-list)

0

(+ (first a-list)

(sum-list/func

(rest a-list)))))

Imperative version:

​

(define (sum-list a-list)

(local [(define sum 0)]

(begin (for-each (λ (element)

(set! sum

(+ sum element)))

a-list)

sum)))

​

​

More focused on what to compute

More focused on how to compute it

What have we changed?

Rules of computation in ASL

Look at the expression

• If it’s a constant (i.e. a number or string), it’s its own value
• If it’s a variable name (i.e. a word, hyphenated phrase, etc.), look its value up in the dictionary
• Parentheses? (Check if it’s one of the special cases from the next slide)
• Otherwise it’s a function call
• (func-expression arg-expression₁ … arg-expression_n)
• Execute all the subexpressions�(func-expression and arg-expression₁ through arg-expression_n)
• Call the value of func-expression, passing it the values of arg-expression₁ through arg-expression_n as inputs
• Use its output as the value of the expression

Special cases: New Imperative Additions

If it starts with λ or lambda:

(λ (name₁ … name_last) result-expression)

• Make a function
• That names its inputs in the dictionary�name₁ … name_last
• Returns the value�of result-expression�(presumably using those names)
• Sets the dictionary back the way it was

If it starts with the the word local

(local [(define name₁ value₁) � …� (define name_last value_last)]� result-expression)

• Run the value expressions
• Assign their values to their respective�names in the dictionary
• Substitutes their values for their respective�names in result-expression
• Runs the substituted result-expression
• Returns its value
• Set the dictionary back the way it was

​

Imperative special forms

If it starts with set!

(set! name value-expression)

• Run value-expression
• Update the value of name�in the dictionary

If it starts with the the word begin

(begin expressions …)

• Run the expressions
• Return the value of the last one