Why Haskell
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Why Haskell

on

  • 5,796 views

Monads, also known as Kleisli triples in Category Theory, are an (endo-)functor together with two natural transformations, which are surprisingly useful in pure languages like Haskell, but this talk ...

Monads, also known as Kleisli triples in Category Theory, are an (endo-)functor together with two natural transformations, which are surprisingly useful in pure languages like Haskell, but this talk will NOT reference monads. Ever. (Well, at least not in this talk.)

Instead what I intend to impress upon an audience of newcomers to Haskell is the wide array of freely available libraries most of which are liberally licensed open source software, intuitive package management, practical build tools, reasonable documentation (when you know how to read it and where to find it), interactive shell (or REPL), mature compiler, stable runtime, testing tools that will blow your mind away, and a small but collaborative and knowledgeable community of developers. Oh, and some special features of Haskell - the language - too!

Statistics

Views

Total Views
5,796
Views on SlideShare
5,466
Embed Views
330

Actions

Likes
12
Downloads
104
Comments
1

7 Embeds 330

http://susanpotter.net 214
http://www.redditmedia.com 95
http://www.linkedin.com 7
http://localhost 5
https://www.linkedin.com 4
http://www.softcursos.com.br 3
http://us-w1.rockmelt.com 2
More...

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

CC Attribution-NonCommercial-NoDerivs LicenseCC Attribution-NonCommercial-NoDerivs LicenseCC Attribution-NonCommercial-NoDerivs License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Why Haskell Presentation Transcript

  • 1. Why Haskell? Susan Potter March 2012
  • 2. What is Haskell? Figure: "pure functional, lazy, polymorphic, statically and strongly typed with type inference . . . "
  • 3. How can I drive this thing? Figure: Photo from "If programming languages were cars" blog post http://machinegestalt.posterous.com/if-programming-languages-were-cars
  • 4. Can I drive Haskell without all this? Figure: No need to know Category Theory proofs, just some intuitions!
  • 5. # finger $(whoami)Login: susan Name: Susan PotterDirectory: /home/susan Shell: /bin/zshPracticing since 1997-09-29 21:18 (GMT) on tty1 from :0Too much unread mail on me@susanpotter.netNow working at Desk.com! Looking for smart developers!;)Plan: github: mbbx6spp twitter: @SusanPotter
  • 6. Are we "doing it wrong"? Figure: Maybe! ;) http://absolutelymadness.tumblr.com/post/17567574522
  • 7. Overview: Choosing a language Many considerations political, human, technical Runtime performance, reliability, configurability Knowledge culture, mindshare, resources, signal to noise ratio Tooling development, build/release, configuration, deployment
  • 8. Overview: Choosing a language Many considerations political, human, technical Runtime performance, reliability, configurability Knowledge culture, mindshare, resources, signal to noise ratio Tooling development, build/release, configuration, deployment
  • 9. Overview: Choosing a language Many considerations political, human, technical Runtime performance, reliability, configurability Knowledge culture, mindshare, resources, signal to noise ratio Tooling development, build/release, configuration, deployment
  • 10. Overview: Choosing a language Many considerations political, human, technical Runtime performance, reliability, configurability Knowledge culture, mindshare, resources, signal to noise ratio Tooling development, build/release, configuration, deployment
  • 11. Overview: Agenda My Claims / Hypotheses Laziness, Functional, Type System Toolkit & Runtime Library Ecosystem Pitfalls & Hurdles
  • 12. My Claims Performance is reasonable on par with Java and C# Mono; 2-3x CPU times of C (approx); BUT always doubt benchmarks http://shootout.alioth.debian.org/u64q/haskell.php Productivity with long-term benefits after initial steep learning curve Haskell types offer stronger verifiability strong and meaningful checks applied Pure functional code is easier to test probably not controversial
  • 13. My Claims Performance is reasonable on par with Java and C# Mono; 2-3x CPU times of C (approx); BUT always doubt benchmarks http://shootout.alioth.debian.org/u64q/haskell.php Productivity with long-term benefits after initial steep learning curve Haskell types offer stronger verifiability strong and meaningful checks applied Pure functional code is easier to test probably not controversial
  • 14. My Claims Performance is reasonable on par with Java and C# Mono; 2-3x CPU times of C (approx); BUT always doubt benchmarks http://shootout.alioth.debian.org/u64q/haskell.php Productivity with long-term benefits after initial steep learning curve Haskell types offer stronger verifiability strong and meaningful checks applied Pure functional code is easier to test probably not controversial
  • 15. My Claims Performance is reasonable on par with Java and C# Mono; 2-3x CPU times of C (approx); BUT always doubt benchmarks http://shootout.alioth.debian.org/u64q/haskell.php Productivity with long-term benefits after initial steep learning curve Haskell types offer stronger verifiability strong and meaningful checks applied Pure functional code is easier to test probably not controversial
  • 16. Haskell "lazy" by default Figure: Photo by Mark Fischer http://www.flickr.com/photos/tom_ruaat/4431626234/
  • 17. Haskell "lazy" by default Figure: Photo by Mark Fischer http://www.flickr.com/photos/tom_ruaat/4431626234/ (jarring for mainstream programmers)
  • 18. Example: doubleSum 3 (2 + 3) Call by value doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 19. Example: doubleSum 3 (2 + 3) Call by value doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 20. Example: doubleSum 3 (2 + 3) Call by value doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 21. Example: doubleSum 3 (2 + 3) Call by value doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 22. Example: doubleSum 3 (2 + 3) Call by value doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 23. Example: doubleSum 3 (2 + 3) Call by value doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 24. Example: doubleSum 3 (2 + 3) Call by value (evaluates inner-most expressions first) doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 25. Example: doubleSum 3 (2 + 3) Call by value (evaluates inner-most expressions first) doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 26. Example: doubleSum 3 (2 + 3) Call by value (evaluates inner-most expressions first) doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 27. Example: doubleSum 3 (2 + 3) Call by value (evaluates inner-most expressions first) doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 28. Example: doubleSum 3 (2 + 3) Call by value (evaluates inner-most expressions first) doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name (evaluates outer-most expressions first) doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)
  • 29. Laziness in Haskell is . . . CallByName + SharingOptimization + PossibleMinorOverhead
  • 30. Laziness: Buyer Beware filter (λ x → x < 6) [1..] (never terminates) takeWhile (λ x → x < 6) [1..] (does terminate) dropWhile (λ x → x >= 6) [1..] (does not terminate) Need to understand implications of laziness on functions Laziness with I/O implications lazy I/O with handles is problematic, but iteratee idiom solves most of these. There are a number of libraries available to help with this: enumerator, pipes, . . .
  • 31. Laziness: Buyer Beware filter (λ x → x < 6) [1..] (never terminates) takeWhile (λ x → x < 6) [1..] (does terminate) dropWhile (λ x → x >= 6) [1..] (does not terminate) Need to understand implications of laziness on functions Laziness with I/O implications lazy I/O with handles is problematic, but iteratee idiom solves most of these. There are a number of libraries available to help with this: enumerator, pipes, . . .
  • 32. Laziness: Buyer Beware filter (λ x → x < 6) [1..] (never terminates) takeWhile (λ x → x < 6) [1..] (does terminate) dropWhile (λ x → x >= 6) [1..] (does not terminate) Need to understand implications of laziness on functions Laziness with I/O implications lazy I/O with handles is problematic, but iteratee idiom solves most of these. There are a number of libraries available to help with this: enumerator, pipes, . . .
  • 33. Laziness: Buyer Beware filter (λ x → x < 6) [1..] (never terminates) takeWhile (λ x → x < 6) [1..] (does terminate) dropWhile (λ x → x >= 6) [1..] (does not terminate) Need to understand implications of laziness on functions Laziness with I/O implications lazy I/O with handles is problematic, but iteratee idiom solves most of these. There are a number of libraries available to help with this: enumerator, pipes, . . .
  • 34. Laziness: Buyer Beware filter (λ x → x < 6) [1..] (never terminates) takeWhile (λ x → x < 6) [1..] (does terminate) dropWhile (λ x → x >= 6) [1..] (does not terminate) Need to understand implications of laziness on functions Laziness with I/O implications lazy I/O with handles is problematic, but iteratee idiom solves most of these. There are a number of libraries available to help with this: enumerator, pipes, . . .
  • 35. Laziness: Also Pretty Suuweeeet! Infinite sequences/lists made possible Recursive functions become practical Recursive types become simple Much more as well ...
  • 36. Laziness: Also Pretty Suuweeeet! Infinite sequences/lists made possible Recursive functions become practical Recursive types become simple Much more as well ...
  • 37. Laziness: Also Pretty Suuweeeet! Infinite sequences/lists made possible Recursive functions become practical Recursive types become simple Much more as well ...
  • 38. Laziness: Also Pretty Suuweeeet! Infinite sequences/lists made possible Recursive functions become practical Recursive types become simple Much more as well ...
  • 39. Purity + Laziness=> Reasoning Equality (referential transparency) Can replace occurrences of LHS with RHS Higher Order Functions encourage exploitation of higher-level patterns Function Composition leads to greater reuse
  • 40. Purity + Laziness=> Reasoning Equality (referential transparency) Can replace occurrences of LHS with RHS Higher Order Functions encourage exploitation of higher-level patterns Function Composition leads to greater reuse
  • 41. Purity + Laziness=> Reasoning Equality (referential transparency) Can replace occurrences of LHS with RHS Higher Order Functions encourage exploitation of higher-level patterns Function Composition leads to greater reuse
  • 42. mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xsmyproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xsmyany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr ( x b -> b || pred x) False xsmyall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr ( x b -> b && pred x) True xs
  • 43. mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xsmyproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xsmyany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr ( x b -> b || pred x) False xsmyall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr ( x b -> b && pred x) True xs
  • 44. mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xsmyproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xsmyany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr ( x b -> b || pred x) False xsmyall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr ( x b -> b && pred x) True xs
  • 45. mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xsmyproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xsmyany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr ( x b -> b || pred x) False xsmyall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr ( x b -> b && pred x) True xs
  • 46. mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xsmyproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xsmyany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr ( x b -> b || pred x) False xsmyall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr ( x b -> b && pred x) True xs
  • 47. mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xsmyproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xsmyany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr ( x b -> b || pred x) False xsmyall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr ( x b -> b && pred x) True xs
  • 48. mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xsmyproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xsmyany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr ( x b -> b || pred x) False xsmyall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr ( x b -> b && pred x) True xs
  • 49. class Monoid m where mappend :: m -> m -> m mempty :: minstance Num a => Monoid a where mappend :: m -> m -> m mappend x y = (+) x y mempty :: m mempty = 0instance Monoid Bool where mappend :: m -> m -> m mappend True _ = True mappend _ True = True mappend _ _ = False mempty :: m
  • 50. class Monoid m where mappend :: m -> m -> m mempty :: minstance Num a => Monoid a where mappend :: m -> m -> m mappend x y = (+) x y mempty :: m mempty = 0instance Monoid Bool where mappend :: m -> m -> m mappend True _ = True mappend _ True = True mappend _ _ = False mempty :: m
  • 51. class Monoid m where mappend :: m -> m -> m mempty :: minstance Num a => Monoid a where mappend :: m -> m -> m mappend x y = (+) x y mempty :: m mempty = 0instance Monoid Bool where mappend :: m -> m -> m mappend True _ = True mappend _ True = True mappend _ _ = False mempty :: m
  • 52. Haskell type signatures can . . . express side effects e.g. String -> IO Int declare computational strategies e.g. Num a => [a] -> Sum a impose constraints e.g. Num a => a -> a question value availability e.g. String -> Maybe Int verify client-server protocol dialogs? an exercise for reader ;)
  • 53. Haskell type signatures can . . . express side effects e.g. String -> IO Int declare computational strategies e.g. Num a => [a] -> Sum a impose constraints e.g. Num a => a -> a question value availability e.g. String -> Maybe Int verify client-server protocol dialogs? an exercise for reader ;)
  • 54. Haskell type signatures can . . . express side effects e.g. String -> IO Int declare computational strategies e.g. Num a => [a] -> Sum a impose constraints e.g. Num a => a -> a question value availability e.g. String -> Maybe Int verify client-server protocol dialogs? an exercise for reader ;)
  • 55. Haskell type signatures can . . . express side effects e.g. String -> IO Int declare computational strategies e.g. Num a => [a] -> Sum a impose constraints e.g. Num a => a -> a question value availability e.g. String -> Maybe Int verify client-server protocol dialogs? an exercise for reader ;)
  • 56. Haskell type signatures can . . . express side effects e.g. String -> IO Int declare computational strategies e.g. Num a => [a] -> Sum a impose constraints e.g. Num a => a -> a question value availability e.g. String -> Maybe Int verify client-server protocol dialogs? an exercise for reader ;)
  • 57. Interfaces in OO . . . Figure: Class definitions are married to the interfaces they implement.
  • 58. Interfaces in Haskell: Typeclasses. . . Decouple type definition from interface Allow upstream implementations Extend thirdparty libraries easily Redefine implementations upstream No meaningless "any type" functions Very flexible
  • 59. Interfaces in Haskell: Typeclasses. . . Decouple type definition from interface Allow upstream implementations Extend thirdparty libraries easily Redefine implementations upstream No meaningless "any type" functions Very flexible
  • 60. Interfaces in Haskell: Typeclasses. . . Decouple type definition from interface Allow upstream implementations Extend thirdparty libraries easily Redefine implementations upstream No meaningless "any type" functions Very flexible
  • 61. Interfaces in Haskell: Typeclasses. . . Decouple type definition from interface Allow upstream implementations Extend thirdparty libraries easily Redefine implementations upstream No meaningless "any type" functions Very flexible
  • 62. Interfaces in Haskell: Typeclasses. . . Decouple type definition from interface Allow upstream implementations Extend thirdparty libraries easily Redefine implementations upstream No meaningless "any type" functions Very flexible
  • 63. Interfaces in Haskell: Typeclasses. . . Decouple type definition from interface Allow upstream implementations Extend thirdparty libraries easily Redefine implementations upstream No meaningless "any type" functions Very flexible
  • 64. class (Eq a) => Ord a where compare :: a -> a -> Ordering compare x y | x == y = EQ | x <= y = LT | otherwise = GT (<), (>), (>=), (<=) :: a -> a -> Bool ... max, min :: a -> a -> a ...
  • 65. Typically this just works . . . data SimpleShape = Square { size :: Double } | Circle { radius :: Double } deriving (Eq, Ord, Show) We explicitly use the default definitions. . . and when it doesn’t . . . instance Ord SimpleShape where ...
  • 66. Are you awake? Figure: http://absolutelymadness.tumblr.com/post/18126913457
  • 67. Haskell Tooling: Libraries Quite a few Practical libraries Often freely available Permissive OSS licenses
  • 68. Haskell Tooling: Libraries Quite a few Practical libraries Often freely available Permissive OSS licenses
  • 69. Haskell Tooling: Libraries Quite a few Practical libraries Often freely available Permissive OSS licenses
  • 70. Haskell Tooling: Libraries Quite a few Practical libraries Often freely available Permissive OSS licenses
  • 71. Haskell Tooling: Runtime Reasonably performant between JVM 7 and C# Mono performance GC settings easily customized Numerous other runtime options
  • 72. Haskell Tooling: Runtime Reasonably performant between JVM 7 and C# Mono performance GC settings easily customized Numerous other runtime options
  • 73. Haskell Tooling: Runtime Reasonably performant between JVM 7 and C# Mono performance GC settings easily customized Numerous other runtime options
  • 74. Haskell Tooling: Tools Testing tools QuickCheck, HUnit Documentation tools Haddock, Hoogle (lookup documentation) Build tools Cabal, cabal-dev, cabal-nirvana, see "next slide"
  • 75. Haskell Tooling: Tools Testing tools QuickCheck, HUnit Documentation tools Haddock, Hoogle (lookup documentation) Build tools Cabal, cabal-dev, cabal-nirvana, see "next slide"
  • 76. Haskell Tooling: Tools Testing tools QuickCheck, HUnit Documentation tools Haddock, Hoogle (lookup documentation) Build tools Cabal, cabal-dev, cabal-nirvana, see "next slide"
  • 77. Haskell Tooling: DependencyManagement Hackage database of freely available Haskell libraries Cabal great to get started, BUT . . . cabal-dev & similar provides sandboxing, list RVM with gemsets; more important for statically typed environments cabal-nirvana think compatible distribution snapshot of Hackage DB
  • 78. Haskell Tooling: DependencyManagement Hackage database of freely available Haskell libraries Cabal great to get started, BUT . . . cabal-dev & similar provides sandboxing, list RVM with gemsets; more important for statically typed environments cabal-nirvana think compatible distribution snapshot of Hackage DB
  • 79. Haskell Tooling: DependencyManagement Hackage database of freely available Haskell libraries Cabal great to get started, BUT . . . cabal-dev & similar provides sandboxing, list RVM with gemsets; more important for statically typed environments cabal-nirvana think compatible distribution snapshot of Hackage DB
  • 80. Haskell Tooling: DependencyManagement Hackage database of freely available Haskell libraries Cabal great to get started, BUT . . . cabal-dev & similar provides sandboxing, list RVM with gemsets; more important for statically typed environments cabal-nirvana think compatible distribution snapshot of Hackage DB
  • 81. Haskell Tooling: Don’ts for Newbies Use GHC (not HUGS) Hugs written for educational purposes not industrial usage Forget what you know (imperative/OO) relearn programming in a functional-style return is a function name it does not mean return in the C/Java/C# way class does not mean OO-class think decoupled interface with optional default impelementations and a lot more power
  • 82. Haskell Tooling: Don’ts for Newbies Use GHC (not HUGS) Hugs written for educational purposes not industrial usage Forget what you know (imperative/OO) relearn programming in a functional-style return is a function name it does not mean return in the C/Java/C# way class does not mean OO-class think decoupled interface with optional default impelementations and a lot more power
  • 83. Haskell Tooling: Don’ts for Newbies Use GHC (not HUGS) Hugs written for educational purposes not industrial usage Forget what you know (imperative/OO) relearn programming in a functional-style return is a function name it does not mean return in the C/Java/C# way class does not mean OO-class think decoupled interface with optional default impelementations and a lot more power
  • 84. Haskell Tooling: Don’ts for Newbies Use GHC (not HUGS) Hugs written for educational purposes not industrial usage Forget what you know (imperative/OO) relearn programming in a functional-style return is a function name it does not mean return in the C/Java/C# way class does not mean OO-class think decoupled interface with optional default impelementations and a lot more power
  • 85. Haskell Tooling: Suggestions Explicit language extensions Intentionally and explicitly enable per module Sandbox your builds with cabal-dev or similar Think in types and shapes and use Hoogle to lookup based on types and function "shapes"
  • 86. Haskell Tooling: Suggestions Explicit language extensions Intentionally and explicitly enable per module Sandbox your builds with cabal-dev or similar Think in types and shapes and use Hoogle to lookup based on types and function "shapes"
  • 87. Haskell Tooling: Suggestions Explicit language extensions Intentionally and explicitly enable per module Sandbox your builds with cabal-dev or similar Think in types and shapes and use Hoogle to lookup based on types and function "shapes"
  • 88. Oh, the possibilities! Parallel / Concurrency Options threads, dataflow, par, seq "Cloud" Haskell A kind of Erlang/OTP clone in Haskell Data Parallel Haskell GHC extensions to support nested data parallelism accounting, "Nepal" Haskell’s Foreign Function Interface (FFI) Interface with native code from Haskell GPU Programming in Haskell Obsidian, Nikola, GpuGen, numerous papers on this too Much more. . . Research meeting industrial application
  • 89. Oh, the possibilities! Parallel / Concurrency Options threads, dataflow, par, seq "Cloud" Haskell A kind of Erlang/OTP clone in Haskell Data Parallel Haskell GHC extensions to support nested data parallelism accounting, "Nepal" Haskell’s Foreign Function Interface (FFI) Interface with native code from Haskell GPU Programming in Haskell Obsidian, Nikola, GpuGen, numerous papers on this too Much more. . . Research meeting industrial application
  • 90. Oh, the possibilities! Parallel / Concurrency Options threads, dataflow, par, seq "Cloud" Haskell A kind of Erlang/OTP clone in Haskell Data Parallel Haskell GHC extensions to support nested data parallelism accounting, "Nepal" Haskell’s Foreign Function Interface (FFI) Interface with native code from Haskell GPU Programming in Haskell Obsidian, Nikola, GpuGen, numerous papers on this too Much more. . . Research meeting industrial application
  • 91. Oh, the possibilities! Parallel / Concurrency Options threads, dataflow, par, seq "Cloud" Haskell A kind of Erlang/OTP clone in Haskell Data Parallel Haskell GHC extensions to support nested data parallelism accounting, "Nepal" Haskell’s Foreign Function Interface (FFI) Interface with native code from Haskell GPU Programming in Haskell Obsidian, Nikola, GpuGen, numerous papers on this too Much more. . . Research meeting industrial application
  • 92. Oh, the possibilities! Parallel / Concurrency Options threads, dataflow, par, seq "Cloud" Haskell A kind of Erlang/OTP clone in Haskell Data Parallel Haskell GHC extensions to support nested data parallelism accounting, "Nepal" Haskell’s Foreign Function Interface (FFI) Interface with native code from Haskell GPU Programming in Haskell Obsidian, Nikola, GpuGen, numerous papers on this too Much more. . . Research meeting industrial application
  • 93. Oh, the possibilities! Parallel / Concurrency Options threads, dataflow, par, seq "Cloud" Haskell A kind of Erlang/OTP clone in Haskell Data Parallel Haskell GHC extensions to support nested data parallelism accounting, "Nepal" Haskell’s Foreign Function Interface (FFI) Interface with native code from Haskell GPU Programming in Haskell Obsidian, Nikola, GpuGen, numerous papers on this too Much more. . . Research meeting industrial application
  • 94. Questions? Figure: http://www.flickr.com/photos/42682395@N04/ @SusanPotter
  • 95. Questions? Figure: http://www.flickr.com/photos/42682395@N04/ @SusanPotter
  • 96. Bonus: References / Resources Channel 9 Lectures (Erik Meijer) http://channel9.msdn.com/Shows/Going+Deep/ Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1 Learn You A Haskell http://learnyouahaskell.com Haskell Reddit http://www.reddit.com/r/haskell/ Haskell Cafe http://www.haskell.org/mailman/listinfo/haskell-cafe Real World Haskell http://book.realworldhaskell.org/
  • 97. Bonus: References / Resources Channel 9 Lectures (Erik Meijer) http://channel9.msdn.com/Shows/Going+Deep/ Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1 Learn You A Haskell http://learnyouahaskell.com Haskell Reddit http://www.reddit.com/r/haskell/ Haskell Cafe http://www.haskell.org/mailman/listinfo/haskell-cafe Real World Haskell http://book.realworldhaskell.org/
  • 98. Bonus: References / Resources Channel 9 Lectures (Erik Meijer) http://channel9.msdn.com/Shows/Going+Deep/ Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1 Learn You A Haskell http://learnyouahaskell.com Haskell Reddit http://www.reddit.com/r/haskell/ Haskell Cafe http://www.haskell.org/mailman/listinfo/haskell-cafe Real World Haskell http://book.realworldhaskell.org/
  • 99. Bonus: References / Resources Channel 9 Lectures (Erik Meijer) http://channel9.msdn.com/Shows/Going+Deep/ Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1 Learn You A Haskell http://learnyouahaskell.com Haskell Reddit http://www.reddit.com/r/haskell/ Haskell Cafe http://www.haskell.org/mailman/listinfo/haskell-cafe Real World Haskell http://book.realworldhaskell.org/
  • 100. Bonus: References / Resources Channel 9 Lectures (Erik Meijer) http://channel9.msdn.com/Shows/Going+Deep/ Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1 Learn You A Haskell http://learnyouahaskell.com Haskell Reddit http://www.reddit.com/r/haskell/ Haskell Cafe http://www.haskell.org/mailman/listinfo/haskell-cafe Real World Haskell http://book.realworldhaskell.org/
  • 101. Bonus: Brief QuickCheck Examplemodule Tests whereimport Test.QuickCheck (quickCheck)propReverseReverse :: [Char] -> BoolpropReverseReverse s = (reverse . reverse) s == s excuse the weird syntax form, indenting didn’t show up ;(main = do {quickCheck propReverseReverse }