Upload
susan-potter
View
5.516
Download
2
Tags:
Embed Size (px)
DESCRIPTION
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 is 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!
Citation preview
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 [email protected] 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 }