Introduction to Programming

1 / 44

# Introduction to Programming - PowerPoint PPT Presentation

Introduction to Programming. Seif Haridi KTH Peter Van Roy UCL. Introduction. An introduction to programming concepts Simple calculator Declarative variables Functions Structured data (example: lists) Functions over lists Correctness and complexity Lazy functions

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'Introduction to Programming' - Pat_Xavi

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### Introduction to Programming

Seif Haridi

KTH

Peter Van Roy

UCL

S. Haridi and P. Van Roy

Introduction
• An introduction to programming concepts
• Simple calculator
• Declarative variables
• Functions
• Structured data (example: lists)
• Functions over lists
• Correctness and complexity
• Lazy functions
• Concurrency and dataflow
• State, objects, and classes
• Nondeterminism and atomicity

S. Haridi and P. Van Roy

A calculator
• Use the system as a calculator

> Oz

{Browse 9999*9999}

S. Haridi and P. Van Roy

Variables
• Variables are short-cuts for values, they cannot be assigned more than once

declare

V = 9999*9999

{Browse V*V}

• Variable identifiers: is what you type
• Store variable: is part of the memory system
• The declare statement creates a store variable and assigns its memory address to the identifier ’V’ in the environment

S. Haridi and P. Van Roy

Functions
• Compute the factorial function:

declare

fun {Fact N}

if N==0 then 1 else N*{Fact N-1} end

end

• Fact is declared in the environment
• Try large factorial {Browse {Fact 100}}

S. Haridi and P. Van Roy

Composing functions
• Combinations of r items taken from n.
• The number of subsets of size r taken from a set of size n

Comb

declare

fun {Comb N R}

{Fact N} div ({Fact R}*{Fact N-R})

end

Fact

Fact

Fact

• Example of functional abstraction

S. Haridi and P. Van Roy

1

1

1

1

2

1

1

3

3

1

1

4

6

4

1

Structured data (lists)
• Calculate Pascal triangle
• Write a function that calculates the nth row as one structured value
• A list is a sequence of elements:

[1 4 6 4 1]

• The empty list is written nil
• Lists are created by means of ”|” (cons)

declare

H=1

T = [2 3 4 5]

{Browse H|T} % This will show [1 2 3 4 5]

S. Haridi and P. Van Roy

Lists (2)
• Taking lists apart (selecting components)
• A cons has two components a head, and tail

declare L = [5 6 7 8]

L.1 gives 5

L.2 give [6 7 8]

‘|’

6

‘|’

‘|’

7

8

nil

S. Haridi and P. Van Roy

Pattern matching
• Another way to take a list apart is by use of pattern matching with a case instruction

case L of H|T then {Browse H} {Browse T} end

S. Haridi and P. Van Roy

Functions over lists
• Compute the function {Pascal N}
• Takes an integer N, and returns the Nth row of a Pascal triangle as a list
• For row 1, the result is [1]
• For row N, shift to left row N-1 and shift to the right row N-1
• Align and add the shifted rows element-wise to get row N

1

1

1

1

2

1

(0)

1

3

3

1

(0)

1

4

6

4

1

Shift right

[0 1 3 3 1]

[1 3 3 1 0]

Shift left

S. Haridi and P. Van Roy

Functions over lists (2)

Pascal N

declare

fun {Pascal N}

if N==1 then [1]

else

{ShiftLeft {Pascal N-1}}

{ShiftRight {Pascal N-1}}}

end

end

Pascal N-1

Pascal N-1

ShiftLeft

ShiftRight

S. Haridi and P. Van Roy

Functions over lists (3)

fun {ShiftLeft L}

case L of H|T then

H|{ShiftLeft T}

else [0]

end

end

fun {ShiftRight L} 0|L end

case L1 of H1|T1 then

case L2 of H2|T2 then

end

else nil end

end

S. Haridi and P. Van Roy

Top-down program development
• Understand how to solve the problem by hand
• Try to solve the task by decomposing it to simpler tasks
• Devise the main function (main task) in terms of suitable auxiliary functions (subtasks) that simplifies the solution (ShiftLeft, ShiftRight and AddList)
• Complete the solution by writing the auxiliary functions

S. Haridi and P. Van Roy

• ”A program is correct when it does what we would like it to do”
• In general we need to reason about the program:
• Semantics for the language: a precise model of the operations of the programming language
• Program specification: a definition of the output in terms of the input (usually a mathematical function or relation)
• Use mathematical techniques to reason about the program, using programming language semantics

S. Haridi and P. Van Roy

Mathematical induction
• Select one or more input to the function
• Show the program is correct for the simple cases (base case)
• Show that if the program is correct for a given case, it is then correct for the next case.
• For integers base case is either 0 or 1, and for any integer n the next case is n+1
• For lists the base case is nil, or a list with one or few elements, and for any list T the next case H|T

S. Haridi and P. Van Roy

Correctness of factorial

fun {Fact N}

if N==0 then 1 else N*{Fact N-1} end

end

• Base Case: {Fact 0} returns 1
• (N>1),N*{Fact N-1}assume {Fact N-1} is correct, from the spec we see the {Fact N} is N*{Fact N-1}
• More techniques to come !

S. Haridi and P. Van Roy

Complexity
• Pascal runs very slow, try {Pascal 24}
• {Pascal 20} calls: {Pascal 19} twice, {Pascal 18} four times, {Pascal 17} eight times, ..., {Pascal 1} 219 times
• Execution time of a program up to a constant factor is called program’s time complexity.
• Time complexity of {Pascal N} is proportional to 2N (exponential)
• Programs with exponential time complexity are impractical

declare

fun {Pascal N}

if N==1 then [1]

else

{ShiftLeft {Pascal N-1}}

{ShiftRight {Pascal N-1}}}

end

end

S. Haridi and P. Van Roy

Faster Pascal
• Introduce a local variable L
• Compute {FastPascal N-1} only once
• Try with 30 rows.
• FastPascal is called N times, each time a list on the average of size N/2 is processed
• The time complexity is proportional to N2 (polynomial)
• Low order polynomial programs are practical.

fun {FastPascal N}

if N==1 then [1]

else

local L in

L={FastPascal N-1}

end

end

end

S. Haridi and P. Van Roy

Lazy evaluation
• The functions written so far are evaluated eagerly (as soon as they are called)
• Another way is lazy evaluation where a computation is done only when the results is needed
• Calculates the infinite list:0 | 1 | 2 | 3 | ...

declare

funlazy {Ints N}

N|{Ints N+1}

end

S. Haridi and P. Van Roy

Lazy evaluation (2)
• Write a function that computes as many rows of Pascal’s triangle as needed
• We do not know how many beforehand
• A function is lazy if it is evaluated only when its result is needed
• The function PascalList is evaluated when needed

funlazy {PascalList Row}

Row | {PascalList

{ShiftLeft Row}

{ShiftRight Row}}}

end

S. Haridi and P. Van Roy

Lazy evaluation (3)

declare

L = {PascalList [1]}

{Browse L}

{Browse L.1}

{Browse L.2.1}

• Lazy evaluation will avoid redoing work if you decide first you need the 10th row and later the 11th row
• The function continues where it left off

L<Future>

[1]

[1 1]

S. Haridi and P. Van Roy

Higher-order programming
• Assume we want to write another Pascal function which instead of adding numbers performs exclusive-or on them
• It calculates for each number whether it is odd or even (parity)
• Either write a new function each time we need a new operation, or write one generic function that takes an operation (another function) as argument
• The ability to pass functions as argument, or return a function as result is called higher-order programming
• Higher-order programming is an aid to build generic abstractions

S. Haridi and P. Van Roy

Variations of Pascal
• Compute the parity Pascal triangle

fun {Xor X Y} if X==Y then 0 else 1 endend

1

1

1

1

1

1

1

2

1

1

0

1

1

3

3

1

1

1

1

1

1

4

6

4

1

1

0

0

0

1

S. Haridi and P. Van Roy

Higher-order programming

fun {Add N1 N2} N1+N2 end

fun {Xor N1 N2}

if N1==N2 then 0 else 1 end

end

fun {Pascal N} {GenericPascal Add N} end

fun {ParityPascal N}

{GenericPascal Xor N}

end

fun {GenericPascal Op N}

if N==1 then [1]

else L in L = {GenericPascal Op N-1}

{OpList Op {ShiftLeft L} {ShiftRight L}}

end

end

fun {OpList Op L1 L2}

case L1 of H1|T1 then

case L2 of H2|T2 then

{Op H1 H2}|{OpList Op T1 T2}

end

end

else nil end

end

S. Haridi and P. Van Roy

Concurrency
• How to do several things at once
• Concurrency: running several activities each running at its own pace
• A thread is an executing sequential program
• A program can have multiple threads by using the thread instruction
• {Browse 99*99}can immediately respond while Pascal is computing

P in

P = {Pascal 21}

{Browse P}

end

{Browse 99*99}

S. Haridi and P. Van Roy

Dataflow
• What happens when multiple threads try to communicate?
• A simple way is to make communicating threads synchronize on the availability of data (data-driven execution)
• If an operation tries to use a variable that is not yet bound it will wait
• The variable is called a dataflow variable

X

Y

Z

U

*

*

+

S. Haridi and P. Van Roy

Dataflow (II)
• Two important properties of dataflow
• Calculations work correctly independent of how they are partitioned between threads (concurrent activities)
• Calculations are patient, they do not signal error; they wait for data availability
• The dataflow property of variables makes sense when programs are composed of multiple threads

declare X

{Delay 5000} X=99

end

{Browse ‘Start’} {Browse X*X}

declare X

{Browse ‘Start’} {Browse X*X}

end

{Delay 5000} X=99

S. Haridi and P. Van Roy

State
• How to make a function learn from its past?
• We would like to add memory to a function to remember past results
• Adding memory as well as concurrency is an essential aspect of modeling the real world
• Consider {FastPascal N}: we would like it to remember the previous rows it calculated in order to avoid recalculating them
• We need a concept (memory cell) to store, change and retrieve a value
• The simplest concept is a (memory) cell which is a container of a value
• One can create a cell, assign a value to a cell, and access the current value of the cell
• Cells are not variables

declare

C = {NewCell 0}

{Assign C {Access C}+1}

{Browse {Access C}}

S. Haridi and P. Van Roy

Example
• Add memory to Pascal to remember how many times it is called
• The memory (state) is global here
• Memory that is local to a function is called encapsulated state

declare

C = {NewCell 0}

fun {FastPascal N}

{Assign C {Access C}+1}

end

S. Haridi and P. Van Roy

Objects
• Functions with internal memory are called objects
• The cell is invisible outside of the definition

declare

local C in

C = {NewCell 0}

fun {Bump}

{Assign C {Access C}+1}

{Access C}

end

end

declare

fun {FastPascal N}

{Browse {Bump}}

end

S. Haridi and P. Van Roy

Classes
• A class is a ’factory’ of objects where each object has its own internal state
• Let us create many independent counter objects with the same behavior

fun {NewCounter}

local C Bump in

C = {NewCell 0}

fun {Bump}

{Assign C {Access C}+1}

{Access C}

end

Bump

end

end

S. Haridi and P. Van Roy

Classes (2)
• Here is a class with two operations: Bump and Read

fun {NewCounter}

local C Bump in

C = {NewCell 0}

fun {Bump}

{Assign C {Access C}+1}

{Access C}

end

{Access C}

end

end

end

S. Haridi and P. Van Roy

Object-oriented programming
• In object-oriented programming the idea of objects and classes is pushed farther
• Classes keep the basic properties of:
• State encapsulation
• Object factories
• Classes are extended with more sophisticated properties:
• They have multiple operations (called methods)
• They can be defined by taking another class and extending it slightly (inheritance)

S. Haridi and P. Van Roy

Nondeterminism
• What happens if a program has both concurrency and state together?
• This is very tricky
• The same program can give different results from one execution to the next
• This variability is called nondeterminism
• Internal nondeterminism is not a problem if it is not observable from outside

S. Haridi and P. Van Roy

Nondeterminism (2)

declare

C = {NewCell 0}

C = {NewCell 0}

cell C contains 0

t0

{Assign C 1}

cell C contains 1

t1

{Assign C 2}

cell C contains 2 (final value)

t2

time

S. Haridi and P. Van Roy

Nondeterminism (3)

declare

C = {NewCell 0}

C = {NewCell 0}

cell C contains 0

t0

{Assign C 2}

cell C contains 2

t1

{Assign C 1}

cell C contains 1 (final value)

t2

time

S. Haridi and P. Van Roy

Nondeterminism (4)

declare

C = {NewCell 0}

I = {Access C}

{Assign C I+1}

end

J = {Access C}

{Assign C J+1}

end

• What are the possible results?
• Both threads increment the cell C by 1
• Expected final result of C is 2
• Is that all?

S. Haridi and P. Van Roy

Nondeterminism (5)
• Another possible final result is the cell C containing the value 1

C = {NewCell 0}

t0

t1

I = {Access C}

I equal 0

declare

C = {NewCell 0}

I = {Access C}

{Assign C I+1}

end

J = {Access C}

{Assign C J+1}

end

t2

J = {Access C}

J equal 0

t3

{Assign C J+1}

C contains 1

t4

{Assign C I+1}

C contains 1

time

S. Haridi and P. Van Roy

Lessons learned
• Combining concurrency and state is tricky
• Complex programs have many possible interleavings
• Programming is a question of mastering the interleavings
• Famous bugs in the history of computer technology are due to designers overlooking an interleaving (e.g., the Therac-25 radiation therapy machine giving doses 1000’s of times too high, resulting in death or injury)
• If possible try to avoid concurrency and state together
• Encapsulate state and communicate between threads using dataflow
• Try to master interleavings by using atomic operations

S. Haridi and P. Van Roy

Atomicity
• How can we master the interleavings?
• One idea is to reduce the number of interleavings by programming with coarse-grained atomic operations
• An operation is atomic if it is performed as a whole or nothing
• No intermediate (partial) results can be observed by any other concurrent activity
• In simple cases we can use a lock to ensure atomicity of a sequence of operations
• For this we need a new entity (a lock)

S. Haridi and P. Van Roy

Atomicity (2)

declare

L = {NewLock}

lock L then

sequence of ops 1

end

lock L then

sequence of ops 2

end

S. Haridi and P. Van Roy

The program

declare

C = {NewCell 0}

L = {NewLock}

lock L then I in

I = {Access C}

{Assign C I+1}

end

end

lock L then J in

J = {Access C}

{Assign C J+1}

end

end

The final result of C is

always 2

S. Haridi and P. Van Roy

• Write the memorizing Pascal function using the store abstraction (available at http://www.sics.se/~seif/DatalogiII/Examples/Store.oz)

S. Haridi and P. Van Roy

Memoizing FastPascal
• {FastPascal N} New Version
• Make a store S available to FastPascal
• Let K be the number of the rows stored in S (i.e. max row is the Kth row)
• if N is less or equal K retrieve the Nth row from S
• Otherwise, compute the rows numbered K+1 to N, and store them in S
• Return the Nth row from S
• Viewed from outside (as a black box), this version behaves like the earlier one but faster

declare

S = {NewStore}

{Put S 2 [1 1]}

{Browse {Get S 2}}

{Browse {Size S}}

S. Haridi and P. Van Roy