Mid-Term Discussion

Remaining Classes

Thread of control: the von Neumann model

Race conditions

Language Mechanisms

Encapsulation in Java, Eiffel, and Haskell

Self Objects in Java

Categories of languages

Multi-methods

Java: Package; Class/Interface with public, protected, private; nested classes

Eiffel: Class with more versatile publicity; nested classes

Haskell: Module system with controlled import/export; Class/instance types; anonymous functions, let expressions

Functional equivalence

See code example

Distinctions are primarily historical; poorly defined

An "object-oriented" language can be used in a functional style and vice-versa

May capture "flavor" of typical idioms

Not useful as a way to formally taxonomize languages

See code example

Add a method to a list in the message

On invoke, sort list by (reverse) total distance to root

Find furthest method that works

Cache result

Add another method, then resort and invalidate cache

Today: Concurrency; Homework

July 23: Case studies of Perl, Python, Ruby, and AppleScript; Homework

July 30: Case studies of Java, C#, Ada, Dylan; Final goes out

August 6: Final due; Last class summarizes

 

First: blast through flow of control remaining....

Canonical if-then-else

Cascading series of conditions

Haskell: guards for general conditionals

getWord [] = []

getWord a:x

| elem a whitespace = []

| otherwise = a : getWord x

Choose one control path from many

C, C++, Objective-C, Java: switch is glorified goto

Haskell: case uses pattern matching

count Leaf = 0

count Node _ t1 t2 = 1 + count t1 + count t2

Equivalent constructs

Easiest transformation of recursion to iteration is in case of tail recursion: No computation follows recursive call

getWord [] = []

getWord a:x

| elem a whitespace = []

| otherwise = a : getWord x

Compiler recognizes that stack frame can be re-used in place

Explicit specification of order of operations

class Monad m where

return :: a -> m a

(>>=) :: m a -> (a -> m b) -> m b

Satisfying

return a >>= f = f a

m >>= return = m

m >>= (\a -> ((f a) >>= g)) = (m >>= f) >>= g

Return is identity for >>=

>>= is associative

Lambda analogous to naming intermediate results

Haskell

sumT' Leaf = 0

sumT' (Node n t1 t2) =

return n >>= \num ->

sumT' t1 >>= \s1 ->

sumT' t2 >>= \s2 ->

return (num + s1 + s2)

Java

class Node extends Tree {

int sumT() {

int num = number();

int s1 = left.sumT();

int s2 = right.sumT();

return num + s1 + s2; }; //....

Monad makes serial steps explicit

Unspecified order is default

E.g., server and client pair

instance Monad t (Message t)

Random-access memory

State machine/CPU

One state for the machine, one thread of control

Multiple states or multiple machines, multiple threads of control

Shared memory model of concurrent computing

Consider:

public class Racer extends Thread {

public static int a;

protected class R1 extends Thread {

public void run() { a = 1; } };

protected class R2 extends Thread {

public void run() { a = 2; } };

public void run() {

R1 r1 = new R1; R2 r2 = new R2;

r1.start(); r2.start(); yield();

r1.join(); r2.join();

java.io.System.out.println(a); }; };

What happens when we start Racer?

Self-like, but intrinsically parallel and asynchronous

An actor has a mailbox and a script

After a message is received, the script is performed

No guarantee of order anywhere except along consistent route

Feel of a mix of Actors and Shared Memory

A tuple has a collection of slots

Each slot has a name and a queue of objects

Tuples are shared by threads

Anyone can enqueue

Anyone can dequeue

java.util.Hashtable of java.util.LinkedList

Nested threads

Fork/Join

Implicit

Perl, Python, Ruby, and AppleScript

"In a Nutshell" available for each

Or web sites:

perl.org

python.org

ruby-lang.org

apple.com/applescript