1

Gentle Introduction to Programming

Session 6: Lists, Course Summary

2

Review• Sorting, searching and time-complexity analysis • Scala memory model• Guest lecture by Prof. Ronitt Rubinfeld• Object-oriented programming (OOP)

• Classes and Objects• Functional Objects (Rational Numbers example)

3

Todayהפתעה! (+ משובים) •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP (inheritance, hierarchy, polymorphism)

• Go home!

4

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

5

Class as a BlueprintA class is a blueprint of objects

6

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,…), …

7

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

8

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

9

Constructing a Rational

• How client programmer will create a new Rational object?

Class parameters

10

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

?

11

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

12

Usage

• Now we can remove the debug println…

13

Checking Preconditions

• Ensure the data is valid when the object is constructed

• Use require

14

Define “add” Method

• Immutable• Define add:

15

Add Fields• n, d are in scope in the add method• Access then only on the object on which add

was invoked

16

Test Add, Access Fields

17

Self Reference (this)

• Define method lessThan:

• Define method max:

18

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

19

Revised Rational

20

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

21

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 aelse repeat using a b, b a%b

• http://en.wikipedia.org/wiki/Euclidean_algorithm

22

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

23

Implementation

24

Revised Rational

25

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

26

Revised Rational

27

Usage

28

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

29

Usage

• The * method invoked is determined in each case by the type of the right operand

30

Revised Rational

31

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

32

Companion Object

33

Revised Rational

• Define implicit conversion in Rational.scala, after defining object Rational

34

In Eclipse

• In Rational.scala:• Companion object

(object Rational)• Rational class (class

Rational)

• Place the main method in another file

35

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

36

Complete HomeWork• Implement class Complex so it is natural to use

complex numbers• Examples:

37

Todayהפתעה! )+ משובים( •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP (inheritance, hierarchy, polymorphism)

• Go home!

38

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

39

Objective

Bridge the gap for students without prior programming knowledge

40

Course Description

Lectures will be interactive featuring in-class exercises with lots of support

You are expected to work hard!

41

Course PlanSession Material

1 Basic concepts in CS and programming, basic Scala

2 Basic Scala (cont.), Functions

3 Recursion

4 Arrays

5 Sort, Complexity, Object Oriented Programming

6 Summary, Lists, more OOP

42

Why Scala?

• Semester A: Scheme• Semester B: Java• Scala language has some features similar to

Scheme and some to Java• Scala is cool!

43

Summary

• General introduction to CS and programming• Basic Scala• Development tools:

• Interpreter• Eclipse (+ debugger)

• Compiler, Interpreter

44

Compiler

45

Interpreter

46

How it works in Scala

47

Higher Order Functions

101

,1

2

oddk

k

100

1k

k

100

1

2

k

k

48

Recursion

49

Recursion and Efficiency

• The recursive form, however elegant, may be much less efficient

• The number of redundant calls grow exponentially!

Fib(5)

Fib(4) Fib(3)

Fib(3) Fib(2) Fib(2) Fib(1)

Fib(2)

Fib(1)

Fib(6)

Fib(4)

50

Recursive Vs. Iterative Process

Operation pending

No pending operations

51

“Tail” Recursion in Scala

• Scala compiler translate tail-recursion to iterative execution

• Thus, the functions-stack is not growing

52

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

……

53

Arrays - Example

54

Stack, Queue

• Stack – מחסנית• Applications: Function’s stack• Implementation ideas

• Queue – תור, First In First Out (FIFO)• Applications: Scheduling, typing• Implementation idea• Cyclic Queue

55

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]

56

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

57

Bubble Sort Time ComplexityArray of size n

n iterationsi iterations

constant

(n-1 + n-2 + n-3 + …. + 1) * const ~ ½ * n2

58

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)

59

Bucket Sort• Linear-time sorting algorithm! • But: restrictions on data – bounded

integers…

60

Quick Sort

• Want to hear about it?

• http://en.wikipedia.org/wiki/Quicksort

61

Scala Memory Model

• Passing arguments to functions, local names

• Objects in memory

• Stack, Heap, Garbage collection

62

Object-Oriented Programming

• Represent problem-domain entities using a computer language

• Abstraction

• Classes as blueprint / data-types• Scala API (and Java’s)

63

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

64

Guest Lectures

• (soon to be Dr.) Ohad Barzilay• Oded Magger• Prof. Benny Chor• Prof. Ronitt Rubinfeld

65

Todayהפתעה! )+ משובים( •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP (inheritance, hierarchy, polymorphism)

• Go home!

66

Programming in Scala

Chapter 16: Working with Lists Chapter 22: Implementing Lists

67

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)

68

Linked Lists• Built out of links, each link holds:

• Data• Pointer to the next link (tail)

• Pointer to the first element (head)

69

Linked Lists (cont.)• Infinite loop? (linklinklink….)

• Nil – the empty list

• The elements have the same type

70

Lists Vs. Arrays

List Array

Initialization / memory

Economical Wasteful

Insert element Fast Slow

Remove element Fast Slow

Direct access No direct access Direct access

Traverse Linear Linear

71

Functionality• initiate

• isEmpty

• length

• add element

• remove element

• append

• reverse

72

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

73

Initiating Lists

74

Constructing Lists• All lists are build from two fundamental

building blocks:• Nil• :: (cons)

75

Example: Insertion Sort

76

Implementation of ::

77

Implementation of: length, map

78

Concatenating Lists

79

Reverse a List

def rev[T](xs : List[T]) = {

if (xs.isEmpty)

xs

else

rev(xs.tail):::List(xs.head)

}

Complexity?

80

Higher Order Methods

• map• filter• partition• foreach• And more

81

Example - map

map(_+1) map((x:Int)=>x+1)

82

Example – filter, partition

83

Example – filter, partition

84

Example – foreach

85

Example – sort

86

Other Data Structures• Trees• Maps

87

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" )

88

Pattern Matching in Scala

Here's a a set of definitions describing binary trees:

And here's an inorder traversal of binary trees:

This design keeps• purity: all cases are classes or objects• extensibility: you can define more cases elsewhere• encapsulation: only parameters of case classes are revealed

abstract class Tree[T]

case object Empty extends Tree

case class Binary(elem: T, left: Tree[T], right: Tree[T]) extends Tree

def inOrder [T] ( t: Tree[T] ): List[T] = t match { case Empty => List() case Binary(e, l, r) => inOrder(l) ::: List(e) ::: inOrder(r)}

The case modifier of an object or class means you can pattern match on it

89

Todayהפתעה! )+ משובים( •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP (inheritance, hierarchy, polymorphism)

• Go home!

90

More OOP (only talking…)

• Inheritance

• Class Hierarchy

• Polymorphism

91

Scala Hierarchy

92

Todayהפתעה! )+ משובים( •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP )inheritance, hierarchy, polymorphism(

• Go home!

93

Thanks / References• Guest lecturers: Ohad, Oded, Benny,

Amiram, Ronitt

• Administration: Avia, Pnina

• System: Ami, Eitan, Boaz, Eddie

• Initiator: Dr. Lior Wolf

• References:• “Programming in Scala”• Jackie Assa• Scheme Course• Don’t remember

94

חג שמח!תהנו משארית

החופשה!