Martin is setting up a projector to display his laptop presentation. The document discusses concurrency models like threads and their disadvantages like race conditions and deadlocks. It introduces the E programming language which uses objects, composition, distribution and security to allow robust composition of concurrent components without these issues. E uses vats, immediate and eventual message sends, promises to represent asynchronous results, and exceptions to handle errors. While E addresses problems with threads, implementing its model fully would require syntax changes and better data object support.

1. Martin is getting the
projector
to work
with his
laptop.

2. Beyond
Concurrency,
E,
and Smalltalk
Martin McClure
Threads

4. A unicorn
at a
birthday party

5. A unicorn
at a
birthday party
(Thanks, Nancy!)

6. Beyond
Threads

7. Threads

8. Sequential
Model

9. Sequential
Model
•One
•Thing
•After
•Another

10. Sequential
Model
•One
•Thing
•After
•Another
•(branching, call/return)

11. Sequential
Model
•One
•Thing
•At
•A
•Time

12. Shared-State
Thread Model
•Many threads
•Each is sequential
•State is shared

13. Thread
Advantages
•>1 thing “at once”
•Program sequentially

14. Thread
Drawbacks
•Program sequentially
•Execute randomly

15. Thread
Drawbacks
•Race conditions

16. Thread
Drawbacks
•Race conditions
•Deadlock

17. Thread
Drawbacks
•Must understand entire
system. Impossible.

18. Threads
are
Bad

19. Why Threads Are A Bad Idea September 28, 1995, slide <number>
What's Wrong With Threads?
Too hard for most programmers to use.
Even for experts, development is painful.
casual wizardsall programmers
Visual Basic programmers
C programmers
C++ programmers
Threads programmers

20. “The Problem
with Threads”
Edward A. Lee

21. Beyond
Threads

22. Beyond
Threads
E

23. These ideas are
not new.

24. What's
E
all about?

25. When separately written
programs are composed so that
they may cooperate, they may
instead destructively interfere in
unanticipated ways. These
hazards limit the scale and
functionality of the software
systems we can successfully
compose.

26. Great progress on the
composition problem has been
made within the object
paradigm, chiefly in the context
of sequential, single-machine
programming among
benign components.

27. We … extend this success to
support robust composition of
concurrent and potentially
malicious components
distributed over potentially
malicious machines.

28. E
•Objects
•Composition
•Concurrency
•Distribution
•Security

29. Vat

30. Two kinds of send
•immediate
•eventual

31. Vat

32. Two kinds of
object reference

33. Object Reference
•Assign to a variable
•Send a message

34. An Object
Reference is a
channel through
which you can send
a message.

35. Two kinds of
object reference
•near
•eventual

36. Two kinds of
object reference
•near
• immediate send
• eventual send
•eventual
• eventual send only

38. Message
•receiver
•selector
•arguments

39. Arguments
•Near references in the
sending vat become
eventual references when
the message is received in
another vat.

40. Data Objects
•Transitively immutable
•Passed by copying
•Receiver sees a near
reference in its vat

41. (breathe)

42. Immediate send
waits for a response
before returning

43. Eventual send
returns immediately

44. Eventual send
returns immediately
But what does it
return?

45. Promise
•Eventual reference to
the result

46. Promise
•Resolver
• One for each promise
• Sent with message
• Tells promise what
object it represents

47. Promise
•Messages sent to promise
• Before resolved
• Queued
• When resolved
• Queued messages sent
• Once resolved
• Equivalent to resolution

48. Latency
workQueue removeFirst
process = 'done'.

49. Pipelining
workQueue removeFirst
process = 'done'.

50. When Things
go
Wrong

51. Exceptions
•Promise resolves to
broken reference
•Any message sent to the
promise signals the
exception in the sending
vat

52. Odds & Ends
•When-Catch expression
• Multi-way join
•Guaranteed order of
delivery

53. Is all this a
good idea?

54. Advantages
•No race conditions
•No deadlock
•Fairly straightforward
model
•Enables distribution
•More easily enables
multi-core use

55. Drawbacks
•Datalock
•Multi-vat recursive
algorithms require
special handling

56. Is all this a
good idea?

57. What would
it take?

58. Changes
•Syntax for eventual
send
•Better support for data
objects

59. #= == #==

60. E
erights.org

61. Beyond
Concurrency,
E,
and Smalltalk
Martin McClure
Threads