Why Haskell?

Susan Potter

March 2012

What is Haskell?

Figure: "pure functional, lazy, polymorphic, statically and strongly typed with type inference . . . "

How can I drive this thing?

Figure: Photo from "If programming languages were cars" blog posthttp://machinegestalt.posterous.com/if-programming-languages-were-cars

Can I drive Haskell without all this?

Figure: No need to know Category Theory proofs, just some intuitions!

# 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: mbbx6spptwitter: @SusanPotter

Are we "doing it wrong"?

Figure: Maybe! ;)http://absolutelymadness.tumblr.com/post/17567574522

Overview: Choosing a language

Many considerationspolitical, human, technical

Runtimeperformance, reliability, configurability

Knowledgeculture, mindshare, resources, signal to noise ratio

Toolingdevelopment, build/release, configuration, deployment

Overview: Choosing a language

Many considerationspolitical, human, technical

Runtimeperformance, reliability, configurability

Knowledgeculture, mindshare, resources, signal to noise ratio

Toolingdevelopment, build/release, configuration, deployment

Overview: Choosing a language

Many considerationspolitical, human, technical

Runtimeperformance, reliability, configurability

Knowledgeculture, mindshare, resources, signal to noise ratio

Toolingdevelopment, build/release, configuration, deployment

Overview: Choosing a language

Many considerationspolitical, human, technical

Runtimeperformance, reliability, configurability

Knowledgeculture, mindshare, resources, signal to noise ratio

Toolingdevelopment, build/release, configuration, deployment

Overview: Agenda

My Claims / Hypotheses

Laziness, Functional, Type System

Toolkit & Runtime

Library Ecosystem

Pitfalls & Hurdles

My Claims

Performance is reasonableon 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 benefitsafter initial steep learning curve

Haskell types offer stronger verifiabilitystrong and meaningful checks applied

Pure functional code is easier to testprobably not controversial

My Claims

Performance is reasonableon 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 benefitsafter initial steep learning curve

Haskell types offer stronger verifiabilitystrong and meaningful checks applied

Pure functional code is easier to testprobably not controversial

My Claims

Performance is reasonableon 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 benefitsafter initial steep learning curve

Haskell types offer stronger verifiabilitystrong and meaningful checks applied

Pure functional code is easier to testprobably not controversial

My Claims

Performance is reasonableon 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 benefitsafter initial steep learning curve

Haskell types offer stronger verifiabilitystrong and meaningful checks applied

Pure functional code is easier to testprobably not controversial

Haskell "lazy" by default

Figure: Photo by Mark Fischerhttp://www.flickr.com/photos/tom_ruaat/4431626234/

(jarring for mainstream programmers)

Haskell "lazy" by default

Figure: Photo by Mark Fischerhttp://www.flickr.com/photos/tom_ruaat/4431626234/

(jarring for mainstream programmers)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

Laziness in Haskell is . . .

CallByName

+ SharingOptimization

+ PossibleMinorOverhead

Laziness: Buyer Bewarefilter (λ x → x < 6) [1..](never terminates)

takeWhile (λ x → x < 6) [1..](does terminate)

dropWhile (λ x → x >= 6) [1..](does not terminate)

Need to understand implicationsof laziness on functions

Laziness with I/O implicationslazy 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, . . .

Laziness: Buyer Bewarefilter (λ x → x < 6) [1..](never terminates)

takeWhile (λ x → x < 6) [1..](does terminate)

dropWhile (λ x → x >= 6) [1..](does not terminate)

Need to understand implicationsof laziness on functions

Laziness with I/O implicationslazy 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, . . .

Laziness: Buyer Bewarefilter (λ x → x < 6) [1..](never terminates)

takeWhile (λ x → x < 6) [1..](does terminate)

dropWhile (λ x → x >= 6) [1..](does not terminate)

Need to understand implicationsof laziness on functions

Laziness with I/O implicationslazy 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, . . .

Laziness: Buyer Bewarefilter (λ x → x < 6) [1..](never terminates)

takeWhile (λ x → x < 6) [1..](does terminate)

dropWhile (λ x → x >= 6) [1..](does not terminate)

Need to understand implicationsof laziness on functions

Laziness with I/O implicationslazy 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, . . .

Laziness: Buyer Bewarefilter (λ x → x < 6) [1..](never terminates)

takeWhile (λ x → x < 6) [1..](does terminate)

dropWhile (λ x → x >= 6) [1..](does not terminate)

Need to understand implicationsof laziness on functions

Laziness with I/O implicationslazy 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, . . .

Laziness: Also Pretty Suuweeeet!

Infinite sequences/listsmade possible

Recursive functionsbecome practical

Recursive typesbecome simple

Much more as well ...

Laziness: Also Pretty Suuweeeet!

Infinite sequences/listsmade possible

Recursive functionsbecome practical

Recursive typesbecome simple

Much more as well ...

Laziness: Also Pretty Suuweeeet!

Infinite sequences/listsmade possible

Recursive functionsbecome practical

Recursive typesbecome simple

Much more as well ...

Laziness: Also Pretty Suuweeeet!

Infinite sequences/listsmade possible

Recursive functionsbecome practical

Recursive typesbecome simple

Much more as well ...

Purity + Laziness=> Reasoning

Equality (referential transparency)Can replace occurrences of LHS with RHS

Higher Order Functionsencourage exploitation of higher-level patterns

Function Compositionleads to greater reuse

Purity + Laziness=> Reasoning

Equality (referential transparency)Can replace occurrences of LHS with RHS

Higher Order Functionsencourage exploitation of higher-level patterns

Function Compositionleads to greater reuse

Purity + Laziness=> Reasoning

Equality (referential transparency)Can replace occurrences of LHS with RHS

Higher Order Functionsencourage exploitation of higher-level patterns

Function Compositionleads to greater reuse

mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xs

myproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xs

myany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr (\ x b -> b || pred x) False xs

myall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr (\ x b -> b && pred x) True xs

mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xs

myproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xs

myany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr (\ x b -> b || pred x) False xs

myall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr (\ x b -> b && pred x) True xs

mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xs

myproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xs

myany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr (\ x b -> b || pred x) False xs

myall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr (\ x b -> b && pred x) True xs

mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xs

myproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xs

myany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr (\ x b -> b || pred x) False xs

myall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr (\ x b -> b && pred x) True xs

mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xs

myproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xs

myany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr (\ x b -> b || pred x) False xs

myall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr (\ x b -> b && pred x) True xs

mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xs

myproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xs

myany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr (\ x b -> b || pred x) False xs

myall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr (\ x b -> b && pred x) True xs

mysum :: Num a => [a] -> amysum xs = foldr (+) 0 xs

myproduct :: Num a => [a] -> amyproduct xs = foldr (*) 1 xs

myany :: (a -> Bool) -> [a] -> Boolmyany pred xs = foldr (\ x b -> b || pred x) False xs

myall :: (a -> Bool) -> [a] -> Boolmyall pred xs = foldr (\ x b -> b && pred x) True xs

class Monoid m wheremappend :: m -> m -> mmempty :: m

instance Num a => Monoid a wheremappend :: m -> m -> mmappend x y = (+) x ymempty :: mmempty = 0

instance Monoid Bool wheremappend :: m -> m -> mmappend True _ = Truemappend _ True = Truemappend _ _ = Falsemempty :: mmempty = False

class Monoid m wheremappend :: m -> m -> mmempty :: m

instance Num a => Monoid a wheremappend :: m -> m -> mmappend x y = (+) x ymempty :: mmempty = 0

instance Monoid Bool wheremappend :: m -> m -> mmappend True _ = Truemappend _ True = Truemappend _ _ = Falsemempty :: mmempty = False

class Monoid m wheremappend :: m -> m -> mmempty :: m

instance Num a => Monoid a wheremappend :: m -> m -> mmappend x y = (+) x ymempty :: mmempty = 0

instance Monoid Bool wheremappend :: m -> m -> mmappend True _ = Truemappend _ True = Truemappend _ _ = Falsemempty :: mmempty = False

Haskell type signatures can . . .

express side effectse.g. String -> IO Int

declare computational strategiese.g. Num a => [a] -> Sum a

impose constraintse.g. Num a => a -> a

question value availabilitye.g. String -> Maybe Int

verify client-server protocol dialogs?an exercise for reader ;)

Haskell type signatures can . . .

express side effectse.g. String -> IO Int

declare computational strategiese.g. Num a => [a] -> Sum a

impose constraintse.g. Num a => a -> a

question value availabilitye.g. String -> Maybe Int

verify client-server protocol dialogs?an exercise for reader ;)

Haskell type signatures can . . .

express side effectse.g. String -> IO Int

declare computational strategiese.g. Num a => [a] -> Sum a

impose constraintse.g. Num a => a -> a

question value availabilitye.g. String -> Maybe Int

verify client-server protocol dialogs?an exercise for reader ;)

Haskell type signatures can . . .

express side effectse.g. String -> IO Int

declare computational strategiese.g. Num a => [a] -> Sum a

impose constraintse.g. Num a => a -> a

question value availabilitye.g. String -> Maybe Int

verify client-server protocol dialogs?an exercise for reader ;)

Haskell type signatures can . . .

express side effectse.g. String -> IO Int

declare computational strategiese.g. Num a => [a] -> Sum a

impose constraintse.g. Num a => a -> a

question value availabilitye.g. String -> Maybe Int

verify client-server protocol dialogs?an exercise for reader ;)

Interfaces in OO . . .

Figure: Class definitions are married to the interfaces they implement.

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

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

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

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

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

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

class (Eq a) => Ord a wherecompare :: a -> a -> Orderingcompare x y | x == y = EQ

| x <= y = LT| otherwise = GT

(<), (>), (>=), (<=) :: a -> a -> Bool...max, min :: a -> a -> a...

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...

Are you awake?

Figure: http://absolutelymadness.tumblr.com/post/18126913457

Haskell Tooling: Libraries

Quite a few

Practical libraries

Often freely available

Permissive OSS licenses

Haskell Tooling: Libraries

Quite a few

Practical libraries

Often freely available

Permissive OSS licenses

Haskell Tooling: Libraries

Quite a few

Practical libraries

Often freely available

Permissive OSS licenses

Haskell Tooling: Libraries

Quite a few

Practical libraries

Often freely available

Permissive OSS licenses

Haskell Tooling: Runtime

Reasonably performantbetween JVM 7 and C# Mono performance

GC settings easily customized

Numerous other runtime options

Haskell Tooling: Runtime

Reasonably performantbetween JVM 7 and C# Mono performance

GC settings easily customized

Numerous other runtime options

Haskell Tooling: Runtime

Reasonably performantbetween JVM 7 and C# Mono performance

GC settings easily customized

Numerous other runtime options

Haskell Tooling: Tools

Testing toolsQuickCheck, HUnit

Documentation toolsHaddock, Hoogle (lookup documentation)

Build toolsCabal, cabal-dev, cabal-nirvana, see "next slide"

Haskell Tooling: Tools

Testing toolsQuickCheck, HUnit

Documentation toolsHaddock, Hoogle (lookup documentation)

Build toolsCabal, cabal-dev, cabal-nirvana, see "next slide"

Haskell Tooling: Tools

Testing toolsQuickCheck, HUnit

Documentation toolsHaddock, Hoogle (lookup documentation)

Build toolsCabal, cabal-dev, cabal-nirvana, see "next slide"

Haskell Tooling: DependencyManagement

Hackagedatabase of freely available Haskell libraries

Cabalgreat to get started, BUT . . .

cabal-dev & similarprovides sandboxing, list RVM with gemsets; more important for statically typed environments

cabal-nirvanathink compatible distribution snapshot of Hackage DB

Haskell Tooling: DependencyManagement

Hackagedatabase of freely available Haskell libraries

Cabalgreat to get started, BUT . . .

cabal-dev & similarprovides sandboxing, list RVM with gemsets; more important for statically typed environments

cabal-nirvanathink compatible distribution snapshot of Hackage DB

Haskell Tooling: DependencyManagement

Hackagedatabase of freely available Haskell libraries

Cabalgreat to get started, BUT . . .

cabal-dev & similarprovides sandboxing, list RVM with gemsets; more important for statically typed environments

cabal-nirvanathink compatible distribution snapshot of Hackage DB

Haskell Tooling: DependencyManagement

Hackagedatabase of freely available Haskell libraries

Cabalgreat to get started, BUT . . .

cabal-dev & similarprovides sandboxing, list RVM with gemsets; more important for statically typed environments

cabal-nirvanathink compatible distribution snapshot of Hackage DB

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 nameit does not mean return in the C/Java/C# way

class does not mean OO-classthink decoupled interface with optional default impelementations and a lot more power

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 nameit does not mean return in the C/Java/C# way

class does not mean OO-classthink decoupled interface with optional default impelementations and a lot more power

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 nameit does not mean return in the C/Java/C# way

class does not mean OO-classthink decoupled interface with optional default impelementations and a lot more power

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 nameit does not mean return in the C/Java/C# way

class does not mean OO-classthink decoupled interface with optional default impelementations and a lot more power

Haskell Tooling: Suggestions

Explicit language extensionsIntentionally and explicitly enable per module

Sandbox your buildswith cabal-dev or similar

Think in types and shapesand use Hoogle to lookup based on types and function "shapes"

Haskell Tooling: Suggestions

Explicit language extensionsIntentionally and explicitly enable per module

Sandbox your buildswith cabal-dev or similar

Think in types and shapesand use Hoogle to lookup based on types and function "shapes"

Haskell Tooling: Suggestions

Explicit language extensionsIntentionally and explicitly enable per module

Sandbox your buildswith cabal-dev or similar

Think in types and shapesand use Hoogle to lookup based on types and function "shapes"

Oh, the possibilities!Parallel / Concurrency Optionsthreads, dataflow, par, seq

"Cloud" HaskellA kind of Erlang/OTP clone in Haskell

Data Parallel HaskellGHC extensions to support nested data parallelism accounting, "Nepal"

Haskell’s Foreign Function Interface (FFI)Interface with native code from Haskell

GPU Programming in HaskellObsidian, Nikola, GpuGen, numerous papers on this too

Much more. . .Research meeting industrial application

Oh, the possibilities!Parallel / Concurrency Optionsthreads, dataflow, par, seq

"Cloud" HaskellA kind of Erlang/OTP clone in Haskell

Data Parallel HaskellGHC extensions to support nested data parallelism accounting, "Nepal"

Haskell’s Foreign Function Interface (FFI)Interface with native code from Haskell

GPU Programming in HaskellObsidian, Nikola, GpuGen, numerous papers on this too

Much more. . .Research meeting industrial application

Oh, the possibilities!Parallel / Concurrency Optionsthreads, dataflow, par, seq

"Cloud" HaskellA kind of Erlang/OTP clone in Haskell

Data Parallel HaskellGHC extensions to support nested data parallelism accounting, "Nepal"

Haskell’s Foreign Function Interface (FFI)Interface with native code from Haskell

GPU Programming in HaskellObsidian, Nikola, GpuGen, numerous papers on this too

Much more. . .Research meeting industrial application

Oh, the possibilities!Parallel / Concurrency Optionsthreads, dataflow, par, seq

"Cloud" HaskellA kind of Erlang/OTP clone in Haskell

Data Parallel HaskellGHC extensions to support nested data parallelism accounting, "Nepal"

Haskell’s Foreign Function Interface (FFI)Interface with native code from Haskell

GPU Programming in HaskellObsidian, Nikola, GpuGen, numerous papers on this too

Much more. . .Research meeting industrial application

Oh, the possibilities!Parallel / Concurrency Optionsthreads, dataflow, par, seq

"Cloud" HaskellA kind of Erlang/OTP clone in Haskell

Data Parallel HaskellGHC extensions to support nested data parallelism accounting, "Nepal"

Haskell’s Foreign Function Interface (FFI)Interface with native code from Haskell

GPU Programming in HaskellObsidian, Nikola, GpuGen, numerous papers on this too

Much more. . .Research meeting industrial application

Oh, the possibilities!Parallel / Concurrency Optionsthreads, dataflow, par, seq

"Cloud" HaskellA kind of Erlang/OTP clone in Haskell

Data Parallel HaskellGHC extensions to support nested data parallelism accounting, "Nepal"

Haskell’s Foreign Function Interface (FFI)Interface with native code from Haskell

GPU Programming in HaskellObsidian, Nikola, GpuGen, numerous papers on this too

Much more. . .Research meeting industrial application

Questions?

Figure: http://www.flickr.com/photos/42682395@N04/

@SusanPotter

Questions?

Figure: http://www.flickr.com/photos/42682395@N04/

@SusanPotter

Bonus: References / ResourcesChannel 9 Lectures (Erik Meijer)http://channel9.msdn.com/Shows/Going+Deep/

Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1

Learn You A Haskellhttp://learnyouahaskell.com

Haskell Reddithttp://www.reddit.com/r/haskell/

Haskell Cafehttp://www.haskell.org/mailman/listinfo/haskell-cafe

Real World Haskellhttp://book.realworldhaskell.org/

Bonus: References / ResourcesChannel 9 Lectures (Erik Meijer)http://channel9.msdn.com/Shows/Going+Deep/

Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1

Learn You A Haskellhttp://learnyouahaskell.com

Haskell Reddithttp://www.reddit.com/r/haskell/

Haskell Cafehttp://www.haskell.org/mailman/listinfo/haskell-cafe

Real World Haskellhttp://book.realworldhaskell.org/

Bonus: References / ResourcesChannel 9 Lectures (Erik Meijer)http://channel9.msdn.com/Shows/Going+Deep/

Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1

Learn You A Haskellhttp://learnyouahaskell.com

Haskell Reddithttp://www.reddit.com/r/haskell/

Haskell Cafehttp://www.haskell.org/mailman/listinfo/haskell-cafe

Real World Haskellhttp://book.realworldhaskell.org/

Bonus: References / ResourcesChannel 9 Lectures (Erik Meijer)http://channel9.msdn.com/Shows/Going+Deep/

Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1

Learn You A Haskellhttp://learnyouahaskell.com

Haskell Reddithttp://www.reddit.com/r/haskell/

Haskell Cafehttp://www.haskell.org/mailman/listinfo/haskell-cafe

Real World Haskellhttp://book.realworldhaskell.org/

Bonus: References / ResourcesChannel 9 Lectures (Erik Meijer)http://channel9.msdn.com/Shows/Going+Deep/

Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1

Learn You A Haskellhttp://learnyouahaskell.com

Haskell Reddithttp://www.reddit.com/r/haskell/

Haskell Cafehttp://www.haskell.org/mailman/listinfo/haskell-cafe

Real World Haskellhttp://book.realworldhaskell.org/

Bonus: Brief QuickCheck Example

module Tests where

import 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 }