Slide 1
Slide 1 text
Why Haskell?
Susan Potter
March 2012
Slide 2
Slide 2 text
What is Haskell?
Figure: "pure functional, lazy, polymorphic, statically and strongly typed with type inference . . . "
Slide 3
Slide 3 text
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
Slide 4
Slide 4 text
Can I drive Haskell without all this?
Figure: No need to know Category Theory proofs, just some intuitions!
Slide 5
Slide 5 text
# finger $(whoami)
Login: susan Name: Susan Potter
Directory: /home/susan Shell: /bin/zsh
Practicing since 1997-09-29 21:18 (GMT) on tty1 from :0
Too much unread mail on [email protected]
Now working at Desk.com! Looking for smart developers!;)
Plan:
github: mbbx6spp
twitter: @SusanPotter
Slide 6
Slide 6 text
Are we "doing it wrong"?
Figure: Maybe! ;)
http://absolutelymadness.tumblr.com/post/17567574522
Slide 7
Slide 7 text
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
Slide 8
Slide 8 text
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
Slide 9
Slide 9 text
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
Slide 10
Slide 10 text
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
Slide 11
Slide 11 text
Overview: Agenda
My Claims / Hypotheses
Laziness, Functional, Type System
Toolkit & Runtime
Library Ecosystem
Pitfalls & Hurdles
Slide 12
Slide 12 text
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
Slide 13
Slide 13 text
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
Slide 14
Slide 14 text
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
Slide 15
Slide 15 text
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
Slide 16
Slide 16 text
Haskell "lazy" by default
Figure: Photo by Mark Fischer
http://www.flickr.com/photos/tom_ruaat/4431626234/
Slide 17
Slide 17 text
Haskell "lazy" by default
Figure: Photo by Mark Fischer
http://www.flickr.com/photos/tom_ruaat/4431626234/
(jarring for mainstream programmers)
Slide 18
Slide 18 text
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)
Slide 19
Slide 19 text
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)
Slide 20
Slide 20 text
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)
Slide 21
Slide 21 text
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)
Slide 22
Slide 22 text
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)
Slide 23
Slide 23 text
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)
Slide 24
Slide 24 text
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)
Slide 25
Slide 25 text
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)
Slide 26
Slide 26 text
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)
Slide 27
Slide 27 text
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)
Slide 28
Slide 28 text
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)
Slide 29
Slide 29 text
Laziness in Haskell is . . .
CallByName
+ SharingOptimization
+ PossibleMinorOverhead
Slide 30
Slide 30 text
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, . . .
Slide 31
Slide 31 text
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, . . .
Slide 32
Slide 32 text
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, . . .
Slide 33
Slide 33 text
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, . . .
Slide 34
Slide 34 text
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, . . .
Slide 35
Slide 35 text
Laziness: Also Pretty Suuweeeet!
Infinite sequences/lists
made possible
Recursive functions
become practical
Recursive types
become simple
Much more as well ...
Slide 36
Slide 36 text
Laziness: Also Pretty Suuweeeet!
Infinite sequences/lists
made possible
Recursive functions
become practical
Recursive types
become simple
Much more as well ...
Slide 37
Slide 37 text
Laziness: Also Pretty Suuweeeet!
Infinite sequences/lists
made possible
Recursive functions
become practical
Recursive types
become simple
Much more as well ...
Slide 38
Slide 38 text
Laziness: Also Pretty Suuweeeet!
Infinite sequences/lists
made possible
Recursive functions
become practical
Recursive types
become simple
Much more as well ...
Slide 39
Slide 39 text
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
Slide 40
Slide 40 text
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
Slide 41
Slide 41 text
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
Slide 42
Slide 42 text
mysum :: Num a => [a] -> a
mysum xs = foldr (+) 0 xs
myproduct :: Num a => [a] -> a
myproduct xs = foldr (*) 1 xs
myany :: (a -> Bool) -> [a] -> Bool
myany pred xs = foldr (\ x b -> b || pred x) False xs
myall :: (a -> Bool) -> [a] -> Bool
myall pred xs = foldr (\ x b -> b && pred x) True xs
Slide 43
Slide 43 text
mysum :: Num a => [a] -> a
mysum xs = foldr (+) 0 xs
myproduct :: Num a => [a] -> a
myproduct xs = foldr (*) 1 xs
myany :: (a -> Bool) -> [a] -> Bool
myany pred xs = foldr (\ x b -> b || pred x) False xs
myall :: (a -> Bool) -> [a] -> Bool
myall pred xs = foldr (\ x b -> b && pred x) True xs
Slide 44
Slide 44 text
mysum :: Num a => [a] -> a
mysum xs = foldr (+) 0 xs
myproduct :: Num a => [a] -> a
myproduct xs = foldr (*) 1 xs
myany :: (a -> Bool) -> [a] -> Bool
myany pred xs = foldr (\ x b -> b || pred x) False xs
myall :: (a -> Bool) -> [a] -> Bool
myall pred xs = foldr (\ x b -> b && pred x) True xs
Slide 45
Slide 45 text
mysum :: Num a => [a] -> a
mysum xs = foldr (+) 0 xs
myproduct :: Num a => [a] -> a
myproduct xs = foldr (*) 1 xs
myany :: (a -> Bool) -> [a] -> Bool
myany pred xs = foldr (\ x b -> b || pred x) False xs
myall :: (a -> Bool) -> [a] -> Bool
myall pred xs = foldr (\ x b -> b && pred x) True xs
Slide 46
Slide 46 text
mysum :: Num a => [a] -> a
mysum xs = foldr (+) 0 xs
myproduct :: Num a => [a] -> a
myproduct xs = foldr (*) 1 xs
myany :: (a -> Bool) -> [a] -> Bool
myany pred xs = foldr (\ x b -> b || pred x) False xs
myall :: (a -> Bool) -> [a] -> Bool
myall pred xs = foldr (\ x b -> b && pred x) True xs
Slide 47
Slide 47 text
mysum :: Num a => [a] -> a
mysum xs = foldr (+) 0 xs
myproduct :: Num a => [a] -> a
myproduct xs = foldr (*) 1 xs
myany :: (a -> Bool) -> [a] -> Bool
myany pred xs = foldr (\ x b -> b || pred x) False xs
myall :: (a -> Bool) -> [a] -> Bool
myall pred xs = foldr (\ x b -> b && pred x) True xs
Slide 48
Slide 48 text
mysum :: Num a => [a] -> a
mysum xs = foldr (+) 0 xs
myproduct :: Num a => [a] -> a
myproduct xs = foldr (*) 1 xs
myany :: (a -> Bool) -> [a] -> Bool
myany pred xs = foldr (\ x b -> b || pred x) False xs
myall :: (a -> Bool) -> [a] -> Bool
myall pred xs = foldr (\ x b -> b && pred x) True xs
Slide 49
Slide 49 text
class Monoid m where
mappend :: m -> m -> m
mempty :: m
instance Num a => Monoid a where
mappend :: m -> m -> m
mappend x y = (+) x y
mempty :: m
mempty = 0
instance Monoid Bool where
mappend :: m -> m -> m
mappend True _ = True
mappend _ True = True
mappend _ _ = False
mempty :: m
Slide 50
Slide 50 text
class Monoid m where
mappend :: m -> m -> m
mempty :: m
instance Num a => Monoid a where
mappend :: m -> m -> m
mappend x y = (+) x y
mempty :: m
mempty = 0
instance Monoid Bool where
mappend :: m -> m -> m
mappend True _ = True
mappend _ True = True
mappend _ _ = False
mempty :: m
Slide 51
Slide 51 text
class Monoid m where
mappend :: m -> m -> m
mempty :: m
instance Num a => Monoid a where
mappend :: m -> m -> m
mappend x y = (+) x y
mempty :: m
mempty = 0
instance Monoid Bool where
mappend :: m -> m -> m
mappend True _ = True
mappend _ True = True
mappend _ _ = False
mempty :: m
Slide 52
Slide 52 text
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 ;)
Slide 53
Slide 53 text
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 ;)
Slide 54
Slide 54 text
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 ;)
Slide 55
Slide 55 text
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 ;)
Slide 56
Slide 56 text
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 ;)
Slide 57
Slide 57 text
Interfaces in OO . . .
Figure: Class definitions are married to the interfaces they implement.
Slide 58
Slide 58 text
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
Slide 59
Slide 59 text
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
Slide 60
Slide 60 text
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
Slide 61
Slide 61 text
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
Slide 62
Slide 62 text
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
Slide 63
Slide 63 text
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
Slide 64
Slide 64 text
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
...
Slide 65
Slide 65 text
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
...
Slide 66
Slide 66 text
Are you awake?
Figure: http://absolutelymadness.tumblr.com/post/18126913457
Slide 67
Slide 67 text
Haskell Tooling: Libraries
Quite a few
Practical libraries
Often freely available
Permissive OSS licenses
Slide 68
Slide 68 text
Haskell Tooling: Libraries
Quite a few
Practical libraries
Often freely available
Permissive OSS licenses
Slide 69
Slide 69 text
Haskell Tooling: Libraries
Quite a few
Practical libraries
Often freely available
Permissive OSS licenses
Slide 70
Slide 70 text
Haskell Tooling: Libraries
Quite a few
Practical libraries
Often freely available
Permissive OSS licenses
Slide 71
Slide 71 text
Haskell Tooling: Runtime
Reasonably performant
between JVM 7 and C# Mono performance
GC settings easily customized
Numerous other runtime options
Slide 72
Slide 72 text
Haskell Tooling: Runtime
Reasonably performant
between JVM 7 and C# Mono performance
GC settings easily customized
Numerous other runtime options
Slide 73
Slide 73 text
Haskell Tooling: Runtime
Reasonably performant
between JVM 7 and C# Mono performance
GC settings easily customized
Numerous other runtime options
Slide 74
Slide 74 text
Haskell Tooling: Tools
Testing tools
QuickCheck, HUnit
Documentation tools
Haddock, Hoogle (lookup documentation)
Build tools
Cabal, cabal-dev, cabal-nirvana, see "next slide"
Slide 75
Slide 75 text
Haskell Tooling: Tools
Testing tools
QuickCheck, HUnit
Documentation tools
Haddock, Hoogle (lookup documentation)
Build tools
Cabal, cabal-dev, cabal-nirvana, see "next slide"
Slide 76
Slide 76 text
Haskell Tooling: Tools
Testing tools
QuickCheck, HUnit
Documentation tools
Haddock, Hoogle (lookup documentation)
Build tools
Cabal, cabal-dev, cabal-nirvana, see "next slide"
Slide 77
Slide 77 text
Haskell Tooling: Dependency
Management
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
Slide 78
Slide 78 text
Haskell Tooling: Dependency
Management
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
Slide 79
Slide 79 text
Haskell Tooling: Dependency
Management
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
Slide 80
Slide 80 text
Haskell Tooling: Dependency
Management
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
Slide 81
Slide 81 text
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
Slide 82
Slide 82 text
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
Slide 83
Slide 83 text
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
Slide 84
Slide 84 text
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
Slide 85
Slide 85 text
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"
Slide 86
Slide 86 text
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"
Slide 87
Slide 87 text
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"
Slide 88
Slide 88 text
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
Slide 89
Slide 89 text
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
Slide 90
Slide 90 text
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
Slide 91
Slide 91 text
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
Slide 92
Slide 92 text
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
Slide 93
Slide 93 text
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
Slide 94
Slide 94 text
Questions?
Figure: http://www.flickr.com/photos/42682395@N04/
@SusanPotter
Slide 95
Slide 95 text
Questions?
Figure: http://www.flickr.com/photos/42682395@N04/
@SusanPotter
Slide 96
Slide 96 text
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/
Slide 97
Slide 97 text
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/
Slide 98
Slide 98 text
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/
Slide 99
Slide 99 text
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/
Slide 100
Slide 100 text
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/
Slide 101
Slide 101 text
Bonus: Brief QuickCheck Example
module Tests where
import Test.QuickCheck (quickCheck)
propReverseReverse :: [Char] -> Bool
propReverseReverse s = (reverse . reverse) s == s
excuse the weird syntax form, indenting didn’t show up ;(
main = do {quickCheck propReverseReverse }