Why is Haskell so hard to learn? (and how to deal with it)

location_city Bengaluru schedule Nov 16th 02:00 - 02:45 PM place Ball Room 2 people 60 Interested

Haskell is notoriously hard to learn. I have struggled with the learning curve. I have seen others struggle with it. And I have seen developers struggling to wield the language effectively even after months of learning.

We'll talk about five things that give Haskell this (understandably) bad rep, and how to effectively deal with them during your learning phase.


Outline/Structure of the Talk

  • Few concepts where Haskell is fundamentally very different from other popular languages
  • Shortcomings of the core language
  • Curse of the Monads (and no, this will not be another monad tutorial)
  • Libraries and documentation
  • Not knowing how to use the type-system effectively

Learning Outcome

You will learn a bunch of tips & trips on how to effectively navigate the Haskell landscape, i.e. what parts of to focus on, what not to bother with (at least till intermediate level).

And, for a brief period of time, you will not feel so bad about struggling with Haskell :-)

Target Audience


Prerequisites for Attendees

Just curiosity about Haskell is good enough.



schedule Submitted 1 year ago

  • Alexander Granin

    Alexander Granin - Hierarchical Free Monads and Software Design in Functional Programming

    Alexander Granin
    Alexander Granin
    Sr. Haskell Developer
    schedule 2 years ago
    Sold Out!
    45 Mins

    Functional Programming is going through the same process of rethinking as Object Oriented Programming has passed already. FP today is not only something mystical, something barely applicable for day-to-day tasks, but rather a whole philosophy of building big, complex applications, with own tools, approaches and methodologies. We can see a lot of ideas about software design and architecture emerging from the FP community: talks, books, articles. We’re actively discussing Final Tagless, Free Monads, effect systems and other approaches, but it seems the theme not yet covered and we don’t know about possibilities we have.

    In this talk, I’ll tell you about the power of Free Monads in building complex applications in Haskell and PureScript. These applications will be satisfying the requirements like maintainability, testability, simplicity. You’ll know how to create a safe concurrent application state, how to divide the application into layers and how to keep the code sane. In fact, you can do the same with Final Tagless or extensible effects, but the approach with hierarchical Free Monads has some specific properties making it the best tool to separate concerns and create a very interesting eDSLs with different semantics.

    The talk is based on the ideas I’m describing in my book “Functional Design and Architecture”. I also gave several talks about this theme earlier (you can find all my talks here).

    I’ve used these ideas to build software for different companies, including Juspay (Bengaluru), Restaumatic (Poland), Enecuum (Hong Kong). We’ve created several interesting technologies that were not possible to make without Free Monads. Some of them are open sourced.

  • Saurabh Nanda

    Saurabh Nanda - Getting property-based testing to work after struggling for 3 years

    Saurabh Nanda
    Saurabh Nanda
    Vacation Labs
    schedule 1 year ago
    Sold Out!
    45 Mins

    I got excited about property-based testing after hearing John Hughes talk at Functional Conf 2016. I tried it that year with QuickCheck, but failed miserably (it almost derailed the entire project delivery). I cribbed about it in my talk at Functional Conf 2017. In 2018, Srihari's talk got me excited again. This time, I tried with Hedgehog, and got it to work!

    This talk is about this journey and its learnings. We'll talk about how Hedgehog was used to test [1]:

    • A Postgres backed task/job queue
    • A small Wai/Servant based webapp

    And no, we will not talk about the most common (and completely useless) example of reversing a list!

    [1] Both of these are part of an open-sourced task/job queue library.

  • Harendra Kumar

    Harendra Kumar - Streamly: Declarative Concurrency and Dataflow Programming in Haskell

    45 Mins

    Overview: Streamly is a Haskell library for writing programs in a high level, declarative data flow programming paradigm. It provides a simple API, very close to standard Haskell lists. A program is expressed as a composition of data processing pipes, generally known as streams. Streams can be generated, merged, chained, mapped, zipped, and consumed concurrently – enabling a high level, declarative yet concurrent composition of programs. Programs can be concurrent or non-concurrent without any significant change. Concurrency is auto scaled based on consumption rate. Programmers do not have to be aware of threads, locking or synchronization to write scalable concurrent programs. Streamly provides C like performance, orders of magnitude better compared to existing streaming libraries.

    Motivation: Haskell has a beautiful abstraction capability. Haskell lists, several streaming and concurrency libraries are some examples of good programming abstractions. The problem is that concurrency is not handled elegantly and declaratively by these libraries. Moreover, the lack of good performance gives rise to special purpose performance centric libraries like text and bytestring creating more confusion. Streamly unifies, lists, streaming, concurrency, logic programming and reactive programming with unparalleled performance. We can finally have a unified string handling.

    Audience: Streamly is designed to express the full spectrum of programs. Do not think that if you are writing a small and simple program it may not be for you. It expresses a small program with the same efficiency, simplicity and elegance as a large scale concurrent application. It unifies many different aspects of special purpose libraries into a single yet simple framework. It is especially suitable for high performance and scalable backend data processing systems. If you use or plan to use any real time streaming or data flow programming frameworks including Apache Flink, Apache Spark or asynchronous/reactive programming frameworks like ReactiveX/RxJs then you may be interested in Streamly.

  • Anupam Jain

    Anupam Jain - Supercharged Web Application development with Purescript

    45 Mins

    UPDATE: Please setup https://github.com/ajnsit/purescript-react-starter (follow the instructions in the README) on your laptops as a **prerequisite**.

    Purescript is a purely functional, strongly typed language, that compiles to Javascript.

    It provides several high quality libraries for frontend development, and comes with excellent tooling and editor support that makes writing code a snap!

    In this talk I will provide a quick introduction to some basics of Purescript, and then dive into an interactive demonstration of building a non-trivial web application from scratch. I will show how to interface with React bindings, and how to interface with some existing Javascript libraries (a React UI component lib).

    The presentation will be interactive and similar to an inpromptu talk I gave which is linked below. However, I will also demonstrate live coding of an actual purescript application which people can follow along.

    Bring your laptop to follow along.

  • Sreenidhi Nair

    Sreenidhi Nair - Learnings from using haskell in production

    20 Mins
    Experience Report

    Over a period of 7 years, we have applied Haskell across Web apps, compilers, parsers for our customers across various industries. This is our report on how some of the unique features of Haskell have not only helped us create stable production environments but also break barriers. On the other hand, there is a high cost of on-boarding new developers and few other pain points. So, is Haskell worth the investment?