Happenings of the First Hands On Haskell Workshop

  1. After spending the initial (slightly chaotic) half an hour helping everyone get set up with their haskell tools:

    • A docker image from a tar hosted on the LAN

    • Downloading haskell-platform for their env, and then running cabal update && cabal install scotty.

  2. Everyone downloaded hoh-code tarball that was hosted locally for them to get started with exercises. Thanks to AJ for coming up with a great set of simple problems.

  3. We proceeded in the following way with Haskell (by Tanmai):

    • Thinking in terms of input and output, and with pure functions only

    • Expressing input-output as type signatures

    • Experimenting with type signatures on ghci with Prelude functions

    • Applying functions from prelude. Like (+) 1 2 and length [1,2,3,4]

    • Starting messing around with src/FunctionsExpr.hs. Type signatures of a few simple functions like add, subtract were written, and their implementation was simply set to undefined

    • The exercise was to implement the functions, and then test them out with ghci

    • We went over basic syntax, expressions, if-else branching, basic recursion

    • The complexity was slightly increased with src/Addendum.hs which contained common functions on lists

    • More examples with pattern matching, and recursion

    • Quintessential quick sort example! Showing the ‘top-down’ thinking at work, the conciseness in implementation

    • Introduction to higher order functions, partial functions, and basic examples showing how functions are just values

  4. After the basic exercises and a little coffee and tea break, we dove into a few more advanced examples of Haskell

  5. We had a session on discussing lazy evaluation, and how purity and lazy evaluation work so well together (by Vamshi)

    • Trying out examples like take n [1..]

    • Discussing composition and laziness with how things like quadrupleMe = doubleMe . doubleMe and how take n (quadrupleMe [1..]) worked so naturally

  6. We then proceeded to another more advanced concept, that offers something very powerful to programmers:

    • Equational reasoning and its impact on refactoring and evolving codebases. Eg: take one bit out, optimize it etc.

    • Understanding how purity and the type system let us have beautiful things like Quickcheck

    • Testing with invariants: x == reverse (reverse x)

    • Testing with reference implementations. Brandon went over a great example of how he tested his streaming solution of the twitter water problem with a elegant 3 line solution by Philip Nilsson. The solution worked for some common inputs, but failed on inputs of a particular pattern. Testing with quickcheck against the elegant reference implementation helped him quickly find the bug. And the automatic test-case shrinking just nailed it.

The session was very interactive, and the great (air-conditioned!) venue was organized thanks to Shahidh and the IITM WebOps guys. A very interested and diverse audience kept the full 4 hours very occupied! We also got to meet some interesting folks from in and around Chennai regularly using Haskell.

We should have the next workshop/meetup soon!