Why Haskell

Context

  • Opinion
  • Anecdotal ( Observations taken from my experiences )
    • Process automation
    • Business Information Systems
    • A project where time travel was important

Starting point

  • I think the way we build software is deeply flawed:
    • It is highly inefficient ( Understanding, Model, Managment, Culture )
    • It deeply flawed, rarely meeting basic customer or user needs
  • On the brightside I think we have tools to drastically improve

What I think is important

  • A lot of things
  • The way we model a problem is one:
    • A conceptual approach to modeling problems.
    • That conceptual approach is simple to apply.

How does this relate to Haskell

  • It not so much haskell as functional.
  • try to model as pools of data with constrained flows between them.
  • I think there is significant utility in persistent data.
  • This is close to a statically typed functional programming model.

Functional programming

  • Pure:
    • What you get out is derived from what you put in.
    • No side effects.
    • No mutation of state.
  • Functions transform or answer questions.
  • Models are build via composition.
  • Use of common data structure is popular.

Benefits of functional programming

  • It provides reasonabilty.
  • You read the code, you know what it does.
  • To recreate you just pass in the same state.
  • High reuse straight out of the box.

Drawback of functional programming

  • It is useless.
  • You can not affect the real world ( No IO ).
  • Haskell Originaly did not support IO.

Challenges in haskell

  • IO:
    • Functors, Applicative, Monads ( IO guaranty order ).
    • You lose the beauty of composition if not carefull.
  • It is easy to create an illegible mess, it feels like it is encouraged.
  • Common data sturctures do not work out of the box.

Statically Types

  • This is not a functional property ( Clojure, LISP )
  • A type is a just a constraint on what values are acceptable.
  • The types are to help the programmer not the compiler.
  • They are checked at compile time.
  • They are throw away at run time.

Benefits/Drawbacks

  • You have to do more upfront thinking.
  • Serialising/Deserialising:
    • has an elegant solution.
    • takes time to understand and appreciate.
  • You catch errors early.
  • Prototyping can be difficult.