Why Haskell

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 post http://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: mbbx6spp twitter: @SusanPotter

Are we "doing it wrong"? Figure: Maybe! ;) http://absolutelymadness.tumblr.com/post/17567574522

Overview: Choosing a language Many considerations political, human, technical Runtime performance, reliability, conﬁgurability Knowledge culture, mindshare, resources, signal to noise ratio Tooling development, build/release, conﬁguration, deployment

Overview: Agenda My Claims / Hypotheses Laziness, Functional, Type System Toolkit & Runtime Library Ecosystem Pitfalls & Hurdles

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 beneﬁts after initial steep learning curve Haskell types offer stronger veriﬁability strong and meaningful checks applied Pure functional code is easier to test probably not controversial

Haskell "lazy" by default Figure: Photo by Mark Fischer http://www.flickr.com/photos/tom_ruaat/4431626234/

Haskell "lazy" by default Figure: Photo by Mark Fischer http://www.flickr.com/photos/tom_ruaat/4431626234/ (jarring for mainstream programmers)

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)

Example: doubleSum 3 (2 + 3) Call by value (evaluates inner-most expressions ﬁrst) 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)

Example: doubleSum 3 (2 + 3) Call by value (evaluates inner-most expressions ﬁrst) doubleSum 3 (2 + 3) → doubleSum 3 5 → 2 * (3 + 5) → 2 * 8 → 16 Call by name (evaluates outer-most expressions ﬁrst) doubleSum 3 (2 + 3) → (λ x -> 2 * (3 + x)) (2 + 3)

Laziness in Haskell is . . . CallByName + SharingOptimization + PossibleMinorOverhead

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

Laziness: Also Pretty Suuweeeet! Inﬁnite sequences/lists made possible Recursive functions become practical Recursive types become simple Much more as well ...

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

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

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

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 ;)

Interfaces in OO . . . Figure: Class deﬁnitions 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

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

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: Runtime Reasonably performant between JVM 7 and C# Mono performance GC settings easily customized Numerous other runtime options

Haskell Tooling: Tools Testing tools QuickCheck, HUnit Documentation tools Haddock, Hoogle (lookup documentation) Build tools Cabal, cabal-dev, cabal-nirvana, see "next slide"

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

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

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"

Oh, the possibilities! Parallel / Concurrency Options threads, dataﬂow, 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

Questions? Figure: http://www.ﬂickr.com/photos/42682395@N04/ @SusanPotter

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/

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 }

http://susanpotter.net	119
http://www.redditmedia.com	95
http://localhost	5
http://us-w1.rockmelt.com	2
http://www.linkedin.com	2

Why Haskell

by Susan Potter on Mar 16, 2012

Accessibility

Categories

Upload Details

Usage Rights

5 Embeds 223

Statistics

Why Haskell Presentation Transcript