Austin Haskell Meetup


We have a fairly successful Haskell meetup going on here in Austin at the moment. I’ve had a lot of questions from people who would like a Haskell meetup in their own city but have found that it’s difficult to get people to come regularly.

The meetup here used to be a monthly meetup at which one or more people would volunteer to give a presentation. It might have been about a Haskell project they were working on, whether for work or hobby, or maybe a presentation about some concept like RankNTypes or monad transformers. But the general format was that someone was presenting and everyone else was listening, asking questions.

The difficult things about that setup are: you need people to volunteer to present, and it can be difficult to accommodate different levels of learners. Some people will attend talks that are far beyond their level, for inspiration; many people will not. And speakers have difficulty knowing how much background knowledge they can assume.

That’s what this meetup had done for a long time, long before I lived in Austin, but it eventually floundered as people drifted off. There had been one meetup not long before it dissolved that had been billed as a “hands-on Haskell lab” that had great turnout. There were some complaints afterwards about some specific issues, particularly about getting sidetracked by questions that were too advanced and/or tangential. But the desire for that type of meetup was clearly there.

When Sukant Hajra and Austin Seipp wanted to get the meetups going again, they approached me about doing the hands-on Haskell lab as a regular event. None of us was sure it’d work or what the optimal setup would be, and we’ve made a few tweaks as we go along. Here’s roughly what we do at this time:

  • We meet twice a month, instead of monthly.

  • The group breaks out into two subgroups. One group is for relative beginners to Haskell; the other for people who are already somewhat familiar with Haskell.

  • My group are the relative beginners. I teach it like I’d teach a language class. I mostly avoid talking about theory (mostly) and instead introduce whatever aspect of Haskell I’m teaching through code examples and exercises. The best way to learn a language is practicing it. The “curriculum” is structured and attendees know what to expect each time they come (mostly) and know it will be building on the last meetup’s content.

  • I try to write what I think of as pedagogical code for these. Pedagogical code differs in some ways from how I might write real code, because I’m explicitly favoring a certain type of readability and attempting to carefully meter the amount of novelty I’m presenting them with each time. This has really been a learning process for me, especially since almost all of the attendees are programmers with a lot of years of experience (many more than I have) in languages I do not speak. So, sometimes things that seem obvious to me (e.g., sum types) are fairly novel to them (depending on where they’re at and what languages they’ve used).

  • I have them code along and write Haskell right there, where I’m available to answer questions.

  • I hope for, expect, and welcome questions. However, I will put off answering questions that I think are too tangential. That’s what the after-meetup time is for.

  • We have a handful of experienced Haskellers who come. Most of them go to the “intermediate” group to help those attendees go deeper into a specific problem. But they’re around, too, when I don’t know how to answer a question (often the case if the question is about whether something is like something in Java or Scala).

  • I never go to the intermediate subgroup, because I’m teaching the other subgroup, but what I’ve heard is they do a few things. One is they might go through someone’s project and look closely at the code and how and why it’s written the way it is. Sometimes that does get into one of the experienced people teaching a topic like monad transformers, and sometimes they’ve ended up having overlap with what we’re doing. I think to a certain extent there’s some stigma about saying one subgroup is “beginner” and the other “intermediate”, and people feel like they shouldn’t admit they have “beginner” level questions and firmly want to be “intermediate”. It probably made more sense to think of it that way when we first started, when the “beginner” group was still learning about how to write folds and what sum types are and whatnot, but I think I’d want to stay away from labeling the subgroups in the future, or perhaps doing more to encourage people to choose based on the topic week to week. I’m not sure what the right answer is there.

  • Another thing the “intermediate” group seems to do sometimes is all read the same white paper and then talk about it. There’s been a suggestion recently that they might run it more like a lab, where each person brings the project they want to work on and the experienced Haskellers help them.

Running a meetup this way requires a fair bit of commitment from the leaders, but we’ve had good turnout. We have them on the first and third Friday of the month, and in my group there are usually 12-15 people, while the other group has usually around 7-10 people. Most people attend consistently, and the meetup seems to be helpful for people.

One of the hard things about running a Haskell meetup (maybe not difficult in a place like NYC or SF!) is you need a really active core group who frequently have cool projects or talks they want to give. In smaller cities, a Haskell meetup may be more successful catering to people who want to learn but aren’t yet at a level where they’re doing interesting independent Haskell projects to present.

We’ve been talking about starting a public Haskell meetup curriculum that might take some of the strain off organizers in other locations by providing a structure to follow, code examples, slides, and exercises, and we’re also talking about starting to record at least my side of the meetups. So perhaps in the future it’d be easier to get this style of meetup startup, should that be wanted.

We do have a slot for a third meetup each month in case we do have someone who wants to give more of a presentation of their projects, and some people only come for that and not for the hands-on workshops. We’re grateful to Cognitive Scale for hosting us up to three times a month (with pizza, even).

If you like my writing, consider buying me coffee or check out Type Classes, where I teach and write about Haskell and Nix.