Actors
	the future of concurrency

my background
	did NeXTstep work at various outfits in mid 90s
	Python and Lua at dotcoms in late 90s
	returned to NeXTstep/OSX in 2001 as an ISV
	wrote Io in 2002 with concurrency in mind...

purpose
	explain actors
	explain coroutines and continuations
	what they are
	how they work
	uses, benefits and costs
	io and some opinions

major points
	trends

	cores
		2  cores in 2002
		4  cores in 2004
		8  cores in 2006? 
		16 cores in 2008?
		32 cores in 2010? (intel rumor)

	cluster computing
		supercomputers -> mimd clusters with simd on nodes
		distributed databases - GFS, memcache, etc
		distributed systems - p2p filesharing, network computing

	challenges
		writing software to take advantage of these trends

	levels
		single core
		multi cores
		multi machines

	single core concurrency
		threads
		coroutines
		continuations

	memory use -> max concurrency

	
		

	explain threads/coros/continuations
	threads aren't magic
	multiple cores suffer from von neumann bottleneck
	real bottleneck isn't cpu anyways it's i/o
	real problem isn't performance, it's easily writing code that avoids bottlenecks

	threads
		more than one thread per cpu is innefficient
		threads are memory hungry - solution coros/cont
		threads are fragile - solution cooperative
	

concurrency
	means multiple simultanious execution contexts 

what is it good for
	easier coding / avoid state machines
	take advantage of available resources

kinds of concurrency
	processes / threads
	stackfull coroutines
	stackless coroutines and continuations

stackfull
	switch execution contexts = swap hw registers
	plays nice with C

stackless
	switching execution contexts at vm level
	doesn't play nice with C

memory costs
	process / thread 1,000,000s
	stackfull coro   10,000s
	stackless coro   100s

Von Neumann Bottleneck
	bus bandwidth has been growing more slowly that core clock speed
	more cores -> less bandwidth per core
	conclusion: cores with shared memory don't scale

Real World Bottlenecks
	bandwidth - memory/network/disk
	memory size

Io
	highly dynamic 
	prototype-based pure oo language
	no statements
	everything is an expression
	expressions are only composed of dynamic message sends
	coroutines and async sockets

