11 December 2013

Haskell DC

I am proud and excited to announce the meetup group Haskell DC.  Our first meetup agenda is open so I envision some discussion and maybe some basic hacking perhaps using Real World Haskell or Learn You a Haskell for Greater Good. Both are freely available online.  In this post I will put forth some ideas that we might consider for future meetups.  I hope to see this grow into a community and am looking forward to contributions from members especially those that are currently working with Haskell.  I hope to see a mix of practical and theoretical discussions and topics. I will also try to grow the group in terms of sponsorship.  We actually have our first sponsor, the local coworking space company Uberoffices is providing us space for our meetups.  I recently added our meetup to haskell.org under East Coast, which makes it seem a little more official.  I have setup social media accounts on Twitter @HaskellDC also use #HaskellDC for HaskellDC tweets.  I created a Google Plus account with the email haskelldc0 at gmail,  haskelldc was taken. I have also created a Community in Google Plus for HaskellDC. I hope to do a Google Hangout for our meetups which was requested by one of our remote members.  I even created a Facebook account if for no other reason but to claim it.  I admit to not being great at the social media stuff but will do my best or perhaps I will get help there from other members.

Learning Haskell has been on my list of things that I want to do for quite a while.  Haskell is attractive to me because it was developed in academia and embodies some mathematical concepts and now it seems to be gaining ground for commercial use.  So it is interesting to both the computer scientist and the working programmer.  I have a few ideas about future meetup topics both practical and theoretical that I wanted to list out in this post. Of course the future is wide open and I am hoping that as a group we develop future ideas with opportunities for anyone to present or lead a coding session.  In researching this post I became overwhelmed by the copious amount of material that there is out there for Haskell.  I plan to write at least one if not two more posts about Haskell in terms of resources, research, and the ecosystem.

The following are some lists of Programming Language Features, Software Development Related Topics, Practical applications, Advanced Programming Areas and Theoretical Topics. This list is derived from areas of my own interests along with areas that I feel are useful to practical software development.  I put these forth as possible topics for consideration for future meetups:

Haskell Language


  • IDE Support
  • Building and Deploying, Production deployment
  • Continuous Integration
  • Package Management
  • Testing
  • Implementations, GHC, etc.

Practical Uses

  • Web Development
  • XML, HTML Processing and parsing
  • Network Client/Server, Web Services, Restful, JSON, SOAP
  • Desktop GUI
  • Graphics support
  • Embedded programming
  • Relational Database Access
  • MongoDB
  • Neo4j
  • Hadoop/HBase
  • Lucene, Elastic Search, Solr
  • Other NoSQL: Casandra, CouchDB, Riak, etc.

Advanced Topics and Uses


Interesting (Haskell Related) Publications

Ok, that’s quite a list. I tried to categorize these as best as I could. Monads show up under theory and language features, although I am not sure but I think they may be considered more of a language idiom.  The list is clearly ambitious.  If we have one meetup per month it would probably take several years to cover all of these topics if that were the plan.  As some of the theoretical topics are pretty advanced, and I hope to someday understand them.  Hopefully as a group maybe we make some progress as the theoretical aspects are important for better application of the practical.

I have heard many positive things said about Haskell in regards to good software development practices and that it facilitates the creation of better quality software which is what I, and most likely all good software developers, are striving for.   One topic that is of great interest to me is software reuse, I have written about it in relation to complexity and generic programming.  The generic programming post takes its title from a paper of the same name, listed above as a Haskell related paper.  Interestingly Edward Kmett mentions in his Haskellcast about his Lens Library that using Haskell facilitates a higher ease of reuse that would require significant discipline, especially for a team, when using an OO language like C++.  Another area is that of testing, while I think testing is important, my experience with TDD is limited, but it seems that TDD increases the amount of code that has to be written and understood.  I have read that Haskell’s type system, like any statically typed language, allows for less testing because of static type checking.  This rings true to me as dynamically typed languages like Python, Javascript, and Ruby need tests to enforce things that a type system would give you. Also, purity and referential transparency eliminate side effects. State still exists but it is managed more cleanly.  Haskell’s concise syntax is another potential benefit which allows more complexity to be expressed and read more easily.  Powerful features like list comprehensions, pattern matching, and abstract datatypes (ADTs) allow for smaller idiomatic code.  Of course this requires programmers that understand all of this.

CS research publications are a primary area of interest for me and I have encountered many that use and mention Haskell.  The list above provides some papers covering some fairly pragmatic topics that should be of interest to working programmers like Generic Programming, Design Patterns, and Data Structures.     I also include Brent Yorgey’s Typeclassopedia which gets a lot of mentions from people giving advice about learning Haskell and starts with the following advice:

 “The standard Haskell libraries feature a number of type classes with algebraic or category-theoretic underpinnings. Becoming a fluent Haskell hacker requires intimate familiarity with them all, yet acquiring this familiarity often involves combing through a mountain of tutorials, blog posts, mailing list archives, and IRC logs. The goal of this article is to serve as a starting point for the student of Haskell wishing to gain a firm grasp of its standard type classes. The essentials of each type class are introduced, with examples, commentary, and extensive references for further reading.

In the course of my own general research and what I did for this post, I can attest to the large amount and overwhelming Haskell related topics both theoretical and practical that are available online.

In my above list of possible theoretical interests to the meetup group, I list Homotopy Type Theory.  The relevance here is of course that Type Theory is relevant to Haskell.  The theory and the book are new, coming out this year.  I wanted to give it special mention because there is a lot of excitement about it, including claims that the theory is potentially revolutionary to both mathematics and computer science.  The book is a daunting 600 pages and very heavy going, however, Robert Harper has done a series of lectures.  I have watched the first lecture and found it very enlightening so I would recommend it, so far anyway.     

So for the meetup, as I mentioned we will probably start off with some easy learning and hacking. I thought it might be fun to try to implement something simple, maybe Fizz Buzz.  Ultimately it would be nice to work to get set up with the ecosystem to do productive things in Haskell. Maybe eventually a group project or some higher level hacking, I have thought it might be interesting to something like work though some of the problems in Think Stats possibly using a Haskell statistics package.

Well those are my ideas, feel free to suggest others or correct me if I got anything wrong, this is all new to me.


  1. Hi Geoff,

    I came by here to review the list of topics you suggested for Haskell meetup topics. I feel like I'm an intermediate-advanced Haskell programmer and could enjoy covering a fair set of the topics above, but I want to pick ones that would be audience appropriate, captivating, and succinct enough to get through in the time allotted.

    So let me run down the list of things and talk about ones I'd probably enjoy then I'll propose a few other topics which I quite enjoy.

    Purely Functional Programming (ups/downs/usage philosophy)
    Laziness (how the Haskell heap works, stupid lazy tricks)
    Immutability (tricks/benefits/details of memory cost/graph reduction)
    Type Inference (how HM works/unification/how dependently typed systems work, i.e. Lambda Pi)
    ADTs (category theoretic hearth, "7 trees in 1", really cool examples, RankNTypes versus ExistentialQuantification)
    Monads (strange monads, Cont as the Mother Monad, Free Monads, Monads as syntax trees with substitution, monad transformers, free monad transformers)
    Type Classes (type class prolog, multiparam type classes and fundeps, type families, reflection/reification, finally tagless encodings)
    Polymorphism (parametricity: theorems for free practical or theoretical)

    Package Management (how I use cabal)
    Testing (the glory of quickcheck!)

    JSON (library review: Aeson!)
    Algorithms (review of some random functional pearl, Russel O'Connor's A Very General Method of Computing Shortest Paths)
    Parsers (You too could have built Parsec/Attoparsec)
    Algebraic Programming (Haskell's algebra, vector-space, linear, or semigroupoids packages)
    Data Visualization (Haskell's diagrams lib)
    Statistics/Mathematical programming (streaming folds a la the reducers package)

    Lambda Calculus (embedding STLC using de Bruijn indicies, HOAS, PHOAS, Bound, etc)
    Type Theory (just enough MLTT to hang yourself with, maybe a touch of HoTT)
    Category Theory (intro/how to think about it, the definition of a monad, the definition of a functor, what are adjunctions)
    Cata/Anamorphisms (explaining the recursion-schemes package, a day with Squiggol, i.e. lenses/bananas/barbed wire)
    Lenses (I've written a few tutorials on FP Complete around lenses)

    And a few topics of my own inspired by this list

    The Static Nature of Traversals (how to see them both as the essence of iteration and something greater)
    Algebra/Coalgebra/Initial/Final encodings of types
    Object Oriented programming in Haskell (they're not at odds!)
    XML processing if I ever finish my xml-mapping lib
    Equational Reasoning (functional pearls)
    Type-driven development a la Agda

    I'm leaving this list here both for brainstorming purposes and also to solicit and feedback on things that might be interesting and appropriate given knowledge of what the group has talked about up until this point.


    1. Joseph,

      Thanks for adding these. I look forward to hearing you present.