Concurrency vs. Parallelism - Codelovers 2013

Version of this talk for the generalist audience at the Codelovers meetup.

Transcript

1. Concurrency vs Parallelism
2. Netburst Intel - mid 2006 Core 1 physical core n physical cores
3. “Cool, my computer will run twice as fast with a dual core CPU!”
4. ACTUALLY NO!
5. http://memegenerator.net/instance/34752699
6. “Concurrency is the composition of indipendently executing things.” - Rob Pike
7. Parallelism is executing indipendent things at once
8. Structure vs Execution
9. Giving Structure
10. Idea #1 Putting concurrency in a non-concurrent set of tools
11. Idea #1 (cont.) AKA: putting the burden of synchronization on the programmer. Also, shared memory :(
12. The common feeling: Managing threads is hard and gets in the way of describing the higher-level problem at hand
13. I've met a number of people who say “Well, I know you don't believe it, but I can write successful threaded programs.” I used to think that, too. But now I think it's just a learning phase, and you aren't reliable until you say “It's impossible to get it right”. http://www.haskell.org/pipermail/haskell-cafe/2008-September/047234.html
14. https://twitter.com/davidlohr/status/288786300067270656
15. If you have to do it, do it this way: - Build small well-described pieces - Reduce causality - Minimize shared state - Use the right synch tool
16. https://twitter.com/stevelosh/status/289419944586792960
17. Idea #2 Design a language with concurrent primitives and let the compiler/VM take care of the hard stuff
18. Idea #2 (cont.) Still non-deterministic, but much simpler to reason about. Also, message passing.
19. The Actor Model Kevin Spacey Msg #1 Msg #2 ... Kate Mara Msg #1 Msg #2 ... Asynchronous messaging
20. So, now we can focus on expressing our solution to the problem :)
21. Idea #3 We write immutable, side-effect free code and let the compiler/VM take care of the rest
22. Idea #3 (cont.) We get some sort of “implicit concurrency”, it’s totally deterministic and free of any hussle
23. qs [] = [] qs (p:xs) = (qs l) ++ [p] ++ (qs g) where l = filter (< p) xs g = filter (>= p) xs Haskell Quicksort
24. qs [] = [] qs (p:xs) = (qs l) ++ [p] ++ (qs g) where l = filter (< p) xs g = filter (>= p) xs Haskell Quicksort
25. qs [] = [] qs (p:xs) = (qs l) ++ [p] ++ (qs g) where l = filter (< p) xs g = filter (>= p) xs Haskell Quicksort
26. qs [] = [] qs (p:xs) = (qs l) ++ [p] ++ (qs g) where l = filter (< p) xs g = filter (>= p) xs Haskell Quicksort
27. qs [] = [] qs (p:xs) = (qs l) ++ [p] ++ (qs g) where l = filter (< p) xs g = filter (>= p) xs Haskell Quicksort
28. Concurrency is hard, let’s go shopping Conclusion:
29. Concurrency enables Parallelism
30. Concurrency makes Parallelism easy!
31. Thanks! @razielgn
32. Material http://ghcmutterings.wordpress.com/2009/10/06/parallelism-concurrency/ http://existentialtype.wordpress.com/2011/03/17/parallelism-is-not-concurrency/ http://stackoverflow.com/questions/1050222/concurrency-vs-parallelism-what-is-the-difference http://www.sauria.com/blog/2009/10/06/concurrency-parallelism/ https://news.ycombinator.com/item?id=4305486 http://concur.rspace.googlecode.com/hg/talk/concur.html