Download The Scala Experience Safe Programming Can be Fun!

Gentle
Introduction to
Programming
Session 6: Lists, Course
Summary
1
Review
• Scala memory model
• Guest lecture by Prof. Ronitt Rubinfeld
• Object-oriented programming (OOP)
• Classes and Objects
• Functional Objects (Rational Numbers example)
2
Today
• )‫ משובים‬+( !‫הפתעה‬
• Finish Functional Objects
• Guest lecture by Dr. Lior Wolf 10:10
• Course Summary ++
• Lists
• More OOP (inheritance, hierarchy, polymorphism)
• Go home!
3
Object-Oriented Programming
(OOP)
• Represent problem-domain entities using a
computer language
• When building a software in a specific domain,
describe the different components of the domain
as types and variables
• Thus we can take another step up in abstraction
4
Class as a Blueprint
A class is a blueprint of objects
5
Car Example
• Members: 4 wheels, steering wheel, horn, color,…
• Every car instance has its own
• Methods: drive, turn left, honk, repaint,…
• Constructors: Car(String color),
Car(Array[Wheels], Engine,…), …
6
Rational Numbers
• A ration number is a number that can be
expressed as a ration n/d (n,d integers, d not 0)
• Examples: 1/2, 2/3, 112/239, 2/1
• Not an approximation
7
Specification
• Add, subtract, multiply, divide
• println should work smoothly
• Immutable (result of an operation is a new rational number)
• It should feel like native language support
8
Constructing a Rational
• How client programmer will create a new
Rational object?
Class parameters
9
Constructing a Rational
• The Scala compiler will compile any code placed in
the class body, which isn’t part of a field or a method
definition, into the primary constructor
?
10
Reimplementing toString
• toString method
• A more useful implementation of toString would
print out the values of the Rational’s numerator and
denominator
• override the default implementation
11
Usage
• Now we can remove the debug println…
12
Checking Preconditions
• Ensure the data is valid when the object is
constructed
• Use require
13
Define “add” Method
• Immutable
• Define add:
14
Add Fields
• n, d are in scope in the add method
• Access then only on the object on which add
was invoked 
15
Test Add, Access Fields
16
Self Reference (this)
• Define method lessThan:
• Define method max:
17
Auxiliary Constructors
• Constructors other then the primary
• Example: a rational number with a denominator
of 1 (e.g., 5/1  5)
• We would like to do: new Rational(5)
• Auxiliary constructor first action: invoke
another constructor of the same class
• The primary constructor is thus the single point
of entry of a class
18
Revised Rational
19
Private Fields and Methods
• 66/42 = 11/7
• To normalize divide the numerator and denominator
by their greatest common divisor (gcd)
• gcd(66,42) = 6  (66/6)/(42/6) = 11/7
• No need for Rational clients to be aware of this
• Encapsulation
20
Off Topic: Calculate gcd
• gcd(a,b) = g
•
•
•
•
a = n * g
b = m * g
gcd(n,m)=1(otherwise g is not the gcd)
a = t * b + r = t * m * g + r  g is a
divisor of r
• gcd(a,b) = gcd(b,a%b)
• The Euclidean algorithm: repeat iteratively:
if (b == 0) return a
else repeat using a  b, b  a%b
• http://en.wikipedia.org/wiki/Euclidean_algorithm
21
Correctness
• Example:
gcd(40,24)  gcd(24,16)  gcd(16,8) 
gcd(8,0)  8
• Prove: g
= gcd(a,b) = gcd(b,a%b)= g1
• g1 is a divisor of a ( g1 ≤ g)
• There is no larger divisor of a (
g1 ≥ g)
• ≤ : a = t * b + r  a = t * h * g1 + v * g1
 g1 is a divisor of a
• ≥ : assume g > g1  a = t * b + r  g is a
divisor of b and r  contradiction
22
Implementation
23
Revised Rational
24
Defining Operators
•
•
•
•
Why not use natural arithmetic operators?
Replace add by the usual mathematical symbol
Operator precedence will be kept
All operations are method calls
25
Revised Rational
26
Usage
27
Method Overloading
• Now we can add and multiply rational numbers!
• What about mixed arithmetic?
• r * 2 won’t work 
• r * new Rational(2) is not nice 
• Add new methods for mixed addition and
multiplication
• Method overloading
• The compiler picks the correct overloaded
method
28
Usage
• The * method invoked is determined in each
case by the type of the right operand
29
Revised Rational
30
Implicit Conversions
• 2 * r  2.*(r)  method call on 2 (Int) 
Int class contains no multiplication method
that takes a Rational argument 
• Create an implicit conversion that
automatically converts integers to rational
numbers when needed
31
Companion Object
32
Revised Rational
• Define implicit conversion in Rational.scala,
after defining object Rational
33
In Eclipse
• In Rational.scala:
• Companion object
(object Rational)
• Rational class (class
Rational)
• Place the main method
in another file
34
Summary
• Customize classes so that they are natural
to use
• fields, methods, primary constructor
• Method overriding
• Self reference (this)
• Define several constructors
• Encapsulation
• Define operators as method
• Method overloading
• Implicit conversions, companion object
35
Complete HomeWork
• Implement class Complex so it is natural to use
complex numbers
• Examples:
36
Today
• )‫ משובים‬+( !‫הפתעה‬
• Finish Functional Objects
• Guest lecture by Dr. Lior Wolf 10:10
• Course Summary ++
• Lists
• More OOP (inheritance, hierarchy, polymorphism)
• Go home!
37
Course Description
This course will provide a gentle
introduction to programming
using Scala for highly motivated
students with little or no prior
experience in programming
38
Objective
Bridge the gap for students without
prior programming knowledge
39
Course Description
You are expected to work hard!
Lectures will be interactive featuring
in-class exercises with lots of support
40
Course Plan
Session
Material
1
2
Basic concepts in CS and programming,
basic Scala
Basic Scala (cont.), Functions
3
Recursion
4
Arrays, Sorting algorithms
5
Object-oriented programming
6
Summary, Lists, more OOP
41
Why Scala?
• Semester A: Scheme
• Semester B: Java
• Scala language has some features similar to
Scheme and some to Java
• Scala is cool!
42
Summary
• General introduction to CS and programming
• Basic Scala
• Development tools:
• Interpreter
• Eclipse (+ debugger)
• Compiler, Interpreter
43
Compiler
44
Interpreter
45
How it works in Scala
46
Higher Order Functions
100
k
k 1
100
2
k

k 1
101
k
k 1,odd
2
47
Recursion
48
Recursion and Efficiency
Fib(6)
• The recursive form,
however elegant, may
be much less efficient
• The number of
redundant calls grow
exponentially!
Fib(4)
Fib(5)
Fib(4)
Fib(3)
Fib(3)
Fib(2)
Fib(2)
Fib(1)
Fib(2)
Fib(1)
49
Recursive Vs. Iterative Process
Operation pending
No pending
operations
50
“Tail” Recursion in Scala
• Scala compiler translate tail-recursion to
iterative execution
• Thus, the functions-stack is not growing
51
Arrays
•
•
•
•
Array: sequential block of memory that
holds variables of the same type
Array can be declared for any type
The array variable itself holds the address
in memory of beginning of sequence
foreach, filter, map,…
…
0
1
2
3
4
5
6
7
8
9
…
s
52
Arrays - Example
53
Stack, Queue
•
Stack – ‫מחסנית‬
•
•
•
Applications: Function’s stack
Implementation ideas
Queue – ‫תור‬, First In First Out (FIFO)
•
•
•
Applications: Scheduling, typing
Implementation idea
Cyclic Queue
54
Binary Search
• Input:
• A sorted array of integers A
• An integer query q
• Output:
• The index of q in A if q is a member of A
• -1 otherwise
• Algorithm:
•
•
•
•
Check the middle element of A
If it is equal to q, return its index
If it is >= q, search for q in A[0,…,middle-1]
If it is < q, search for q in A[middle+1,...,end]
55
Time Complexity of BS
• Worst case analysis
• Size of the inspected array:
n  n/2  n/4  …..  1
• Each step is very fast (a small constant number
of operations)
• There are log2(n) such steps
• So it takes ~ log2(n) steps per search
• Much faster then ~ n
56
Bubble Sort
n iterations
i iterations
constant
n * (n-1 + n-2 + n-3 + …. + 1) * const ~ ½ * n2
57
Marge Sort
•
•
•
•
If the array is of length 0 or 1, then it is already sorted. Otherwise:
Divide the unsorted array into two sub-arrays of about half the size
Sort each sub-array recursively by re-applying merge sort
Merge the two sub-arrays back into one sorted array
n + 2 * (n/2) + 22 * n/22 + 23 * n/23 + … + 2log(n) * n/2log(n) =
n + n + … + n = n * log(n)
log(n)
58
Bucket Sort
• Linear-time sorting algorithm!
• 
• But: restrictions on data – bounded
integers…
59
Quick Sort
• Want to hear about it?
• http://en.wikipedia.org/wiki/Quicksort
60
Scala Memory Model
• Passing arguments to functions, local names
• Objects in memory
• Stack, Heap, Garbage collection
61
Object-Oriented Programming
• Represent problem-domain entities using a
computer language
• Abstraction
• Classes as blueprint / data-types
• Scala API (and Java’s)
62
Rational Numbers Example
• Customize classes so that they are natural
to use
• fields, methods, primary constructor
• Method overriding
• Self reference (this)
• Define several constructors
• Encapsulation
• Define operators as method
• Method overloading
• Implicit conversions, companion object
63
Guest Lectures
• Prof. Nir Shavit
• Prof. Ran Canetti
• Prof. Ronitt Rubinfeld
• Dr. Lior Wolf
64
Real-World Scaling Process
Speedup
1.8x
2x
2.9x
User code
Multicore
Parallelization and Synchronization
require great care…
Art of Multiprocessor Programming
65
65
Mutual Exclusion or “Alice & Bob share a
pond”
A
B
Art of Multiprocessor
Programming
66
66
Complexity and Cryptography
• Hard problems
• Relation to Cryptography/Security
67
How can we understand?
68
The Gold Standard
• linear time algorithms:
• for inputs encoded by n bits/words, allow
cn time steps (constant c)
• Inadequate?
69
Example
Definition: a list of size n is .99-close to sorted if can delete at most
.01n values to make it sorted. Otherwise, .99-far.
Sorted: 1 2 4
Close: 1 4 2
1 4
Far: 45 39 23
5 7 11 14 19 20 21 23 38 39 45
5 7 11 14 19 20 39 23 21 38 45
5 7 11 14 19 20
23
38 45
1 38 4 5 21 20 19 2 7 11 14
1
4 5
7 11 14
Requirements for algorithm:
• pass sorted lists
• if list passes test, can change at most .99 fraction of list to make it
sorted
70
Today
• )‫ משובים‬+( !‫הפתעה‬
• Finish Functional Objects
• Guest lecture by Dr. Lior Wolf 10:10
• Course Summary ++
• Lists
• More OOP (inheritance, hierarchy, polymorphism)
• Go home!
71
Programming in Scala
Chapter 16: Working with Lists
Chapter 22: Implementing Lists
72
Problems with Arrays
• Limited in space (static): the size of an array
is defined as it is created
• Costly to perform dynamic operations (e.g.,
add an element)
73
Linked Lists
• Built out of links, each link holds:
• Data
• Pointer to the next link (tail)
• Pointer to the first element (head)
74
Linked Lists (cont.)
• Infinite loop? (linklinklink….)
• Nil – the empty list
• The elements have the same type
75
Lists Vs. Arrays
List
Array
Initialization /
memory
Insert element
Economical
Wasteful
Fast
Slow
Remove element
Fast
Slow
Direct access
No direct access
Direct access
Traverse
Linear
Linear
76
Functionality
•
•
•
•
•
•
•
initiate
isEmpty
length
add element
remove element
append
reverse
77
Lists in Scala
• List class have a type parameter T (similar
to Arrays…)
•
• List operations are based on three basic
methods:
• isEmpty : Boolean – true iff the list is empty
• head : T – first element in list
• tail : List[T] – a list consisting of the elements
except the first
78
Initiating Lists
79
Constructing Lists
• All lists are build from two fundamental
building blocks:
• Nil
• :: (cons)
80
Example: Insertion Sort
81
Implementation of ::
82
Implementation of: length, map
83
Concatenating Lists
84
Reverse a List
def rev[T](xs : List[T]) = {
if (xs.isEmpty)
xs
else
rev(xs.tail):::List(xs.head)
}
Complexity?
85
Higher Order Methods
•
•
•
•
•
map
filter
partition
foreach
And more
86
Example - map
map(_+1)  map((x:Int)=>x+1)
87
Example – filter, partition
88
Example – filter, partition
89
Example – foreach
90
Example – sort
91
Other Data Structures
• Trees
• Maps
92
Example
var capital = Map( "US"  "Washington",
"France"  "paris",
"Japan"  "tokyo" )
capital += ( "Russia"  "Moskow" )
for ( (country, city)  capital )
capital += ( country  city.capitalize )
assert ( capital("Japan") == "Tokyo" )
93
Pattern Matching in Scala
The case modifier of an object or class
means you can pattern match on it
abstract class Tree[T]
Here's a a set of
definitions describing
binary trees:
case object Empty extends Tree
And here's an
inorder traversal of
binary trees:
This design keeps
def inOrder [T] ( t: Tree[T] ): List[T] = t match {
case Empty
=> List()
case Binary(e, l, r) => inOrder(l) ::: List(e) ::: inOrder(r)
}
case class Binary(elem: T, left: Tree[T], right: Tree[T])
extends Tree
• purity: all cases are classes or objects
• extensibility: you can define more cases elsewhere
• encapsulation: only parameters of case classes are revealed
94
Today
• )‫ משובים‬+( !‫הפתעה‬
• Finish Functional Objects
• Guest lecture by Dr. Lior Wolf 10:10
• Course Summary ++
• Lists
• More OOP (inheritance, hierarchy, polymorphism)
• Go home!
95
More OOP (only talking…)
• Inheritance
• Class Hierarchy
• Polymorphism
96
Scala Hierarchy
97
Today
• )‫ משובים‬+( !‫הפתעה‬
• Finish Functional Objects
• Guest lecture by Dr. Lior Wolf 10:10
• Course Summary ++
• Lists
• More OOP (inheritance, hierarchy, polymorphism)
• Go home!
98
Thanks / References
• Guest lecturers: Nir Shavit, Ran Canetti,
Ronitt Rubinfeld, Lior Wolf
• Administration: Avia, Pnina
• References:
• “Programming in Scala”
• Jackie Assa
• Sheme Course
99
‫שנה טובה!‬
‫תהנו משארית החופשה!‬
‫‪100‬‬