Please help me localize this repo!
Learning Haskell is a good idea, but you don't have to do it alone. The book Haskell Programming from First Principles by Chris Allen and Julie Moronuki provides the perfect curriculum for group study. Having started my own study groups to work through this book, I can attest to the efficacy of doing so: it keeps you motivated, it keeps you on track, and it keeps you honest. You may be able to join an existing group, but it's arguably better to start your own, even if you don't feel qualified. I knew practically nothing about Haskell or functional programming when I started my first group in New York City. In fact, I think that's the best possible situation to be in—your learning isn't impeded or your judgment clouded by past experience or irrelevant expectations, and you're able to learn along with fellow novices. You're all in it together! After all, most Haskell developers—we hope—haven't even been born yet. Start learning today, and you'll still be part of the vanguard.
This repo brings together a number of resources for people who would like to start their own Haskell study groups but aren't sure how to do it. Included here is advice for publicizing your group, guidelines for participants, a recommended schedule, and other resources. If you like what you see, here's what I think you should do:
- If you're starting your own study group, fork this repo and modify it for your own purposes. If you do so, I only ask that you respect the spirit in which this material is offered and not attribute to me any substantial changes to the pedagogy or process.
- Add a link to your study group to the list below, and submit a pull request to this repo to make it public. Only ask to be added if you intend to (more or less) follow my recommendations.
- In your own repo, I suggest you make the
guidelines.mdfile yourREADME.mdinstead, making whatever changes are necessary. You may also link back to this repo if you like. - Some additional resources are included with this repo. Use them. Add more. Expect me to add more over time—maybe.
Haskell Programming from First Principles, colloquially known as the Haskell Book, is the foundation of the course of study proposed by this repo. Do not expect to find adequate alternatives. The authors have provided discount codes in the past to members of study groups, as indicated by the provided guidelines. I cannot, however, personally guarantee discounts myself. Please contact the authors and ask them directly—before you announce the offer to your group.
First steps
You can do it entirely on your own, but I have found Meetup to be a worthwhile venue due to its built-in network effects. Developers and the tech-minded seem to be overrepresented there to begin with, and your group will be announced to anyone who has previously professed a similar interest. If your city or region has its own Haskell Users Group or other even tangentially-related Meetup group, you should ask them to make you an Event Host so you can schedule meetings yourself and not have to pay to start a Meetup yourself. You may or may not receive useful support from the local community, so I wouldn't necessarily count on it. But it doesn't hurt to reach out to any Haskell people in your area and to go in person to various programming-related meetups (Haskell or otherwise) to announce that you're starting a study group. The personal touch still counts for a great deal.
Getting the word out
Once you're committed to starting a group, you need to find members. Trust me, they're out there, waiting for someone with more initiative (that's you) to find them. I recommend casting a wide net. Obviously, you should announce your intentions to the larger Haskell and functional programming communities. But it's also a good idea to reach out to both mainstream developers, who may have an interest in FP, and even non-developers, who may want to explore a new interest or career path. As for the former options, my recommendations are below. For the latter, you'll have to try personal persuasion, rely on word of mouth, and otherwise use your own imagination.
- Reddit is a good place to start. You should post a link to your Meetup on any relevant subreddits. Some suggestions:
- haskell
- functional programming
- programming
- javascript - the preponderance of all developers, particularly those who are new to coding and/or eager to learn new things
- any subreddits for your local community (probably low signal to noise, but you might as well try)
- Hacker News - make sure you have a catchy headline
- Lobsters - generally high quality, but you may need an invite to join
- IRC
#haskell#haskell-beginners
- Slack - you may have to do some research to find the best groups to post to
- FPChat
- Code Newbie
- Elm
- any other dev-related Slacks local to your area, whatever the language or focus—for example, in New York City I posted to these Slacks:
- Haskell Mailing Lists - not necessarily a good direct source of students, but possibly a useful indirect source if you politely ask the recipients to pass along your note to potentially interested parties
- Social media
Location
This is the hard part—finding a physical space to meet. While you could do it at a cafe (or during the off hours in a Whole Foods eating area, which are generally capacious), it's much better to have a private space. A white board and a projector are ideal amenities. Ask prospective members, especially the developers, to inquire at their workplaces. Contact local tech companies. If they already support Haskell or other functional languages, they may be more interested. Or surf around on Meetup to learn where other groups go. I suggest that you have a backup space, if possible, in case your primary location becomes suddenly unavailable.
Schedule
Once you have found a space to meet, you can design a repeatable info page for Meetup (if you're using it) and settle on a schedule. I recommend that you meet at least weekly if you're going to make meaningful progress. Here's an example Meetup page from my own study group in New York.
Pedagogy and Curriculum
This repo contains a separate set of generic guidelines, including a recommended 12-week curriculum covering the first 18 chapters of the Haskell Book, which you may use for your own study group. I highly recommend you simply implement these guidelines as they are and resist the temptation to "soften them up." This way works. Of course, you should add any details particular to your circumstances. For example, your own Meetup page and/or Slack channels.
Whether or not you want to stretch out the curriculum is up to you. The first time I ran a study group, we did the entire book, one chapter a week (one of the longer chapters we split over two weeks). I no longer recommend that approach, as it's hard to get people to commit to weekly meetings for over 30 consecutive weeks. I suggest you start with 12 weeks or however many you feel is appropriate to cover the first 18 chapters of the book, which takes you up through monad. That covers the beginner level material. If there is interest in continuing the study group, you can go ahead and cover the subsequent, intermediate material. It's also perfectly reasonable to expect participants to have gained enough competence and discipline to cover this material on their own.
In addition to the advice and resources contained in this repo, I have previously written about the pedagogy appropriate for this sort of study group on Medium:
Your first meeting
You are likely to attract a large number of people to the first meeting. Most of them will be tourists. In general, you can expect more people to RSVP to all meetings than actually show up. And you can expect a certain rate of attrition over time. For the first meeting, however, do your best to explain the purpose of the study group and how you intend to conduct it. You can field questions if you like, but I wouldn't entertain unsolicited advice, general questions about Haskell, or demands to defend FP in practice.
As quickly as possible, move into the exercises. Since it's the first meeting, a general presentation on lambda calculus could be useful to break the ice, but I'd recommend just doing a quick intro and meet and greet and then divide everyone up into mini-groups to go over their homework, unless you have a very small turnout. You can go over the answers collectively after everyone has had a chance to share their work. It's important to establish group norms at the outset.
Subsequent meetings
More or less, do what you did the first week but without the meet and greet. Newcomers will have to catch up on their own, as you can't constantly be assimilating people who couldn't attend from the beginning. In other words, don't be a martyr, but do invite them to take their own initiative to reach out to their peers outside regular meeting times to cover the work they missed. I have found it useful, when going over exercises collectively, to ask everyone to put their computers away and do them over again on the fly. The repetition is salutary and it also engenders group solidarity. Those who did their homework will still struggle a bit to remember their solutions while those who didn't will quickly come to see the error of their ways.
You may optionally prepare a skeleton code file to fill in during the meeting. This is where a projector comes in handy. The InstanceSigs GHC extension is especially useful for this purpose. As usual, you should evenly divide your screen real estate between the PDF of the Haskell Book and your REPL and/or code file. Make sure you give everyone a chance to contribute in your meetings, including (perhaps especially) the reluctant, lest a few dominant personalities start to take over. Be patient. Be supportive. Have fun. Go out for a snack or a drink afterward. Carry on.
Teaching and participant conduct
Teaching is something that you may or may not get better at with practice. For most study group coordinators, your best bet is to assume the literal role of coordinator and not try to teach (that is, lecture). You'll have enough to do just making sure your meetings run smoothly. For smaller-scale interactions, try to listen and meet learners on their own terms. Chris Done has written an interesting blog post on the subject. I'm not completely convinced of the efficacy of the Socratic method, but I certainly agree that it's counter-productive to give away the answers to tough problems.
You should probably decide on some behavioral guidelines for your group beforehand, so participants have at least tacitly agreed to be kind and cooperative. The Recurse Center's social rules are a good place to start. If you feel the need to extend my own rather vague formulations, then do so. But never let rules prevent you from enforcing decorum or, conversely, compel you to act against your better judgment.
Paying it forward
Once your study group has wrapped up, what next? You can certainly move on to intermediate or advanced material. Better yet, you can start over again from the beginning. This community needs more people, and there will always be demand for beginner-friendly study groups. If your experience is anything like mine, you'll have had many people find out about your study group too late to join. If you don't want to do it again yourself, an even better solution is to appoint a successful "graduate" of your first study group to run the second one. And so on, and so on. It's the least they can do to repay all your hard work as an organizer, right?
The following list of study groups have adopted or adapted the format and guidelines proposed in this repo. Any group may submit a pull request to be added to the list. A listing here does not constitute an endorsement.
Europe
North America
- haskell-lang.org - A handy portal to the Haskell ecosystem
- How to learn Haskell - A guide for getting started with Haskell from one of the authors of the Haskell Book
- School of Haskell - Some tutorials from the good people at FP Complete
- A Haskell Study Syllabus - Also from FP Complete
- HaskellWiki - Lots of articles on a variety of topics
- Typeclassopedia - Part of the HaskellWiki, a useful reference
- Haskell WikiBook - A supplement to the HaskellWiki
- Haskell is easy - A curated list of Haskell libraries
- Haskell Libraries - A curated list, with links to tutorials
- Haskell on Stack Overflow - Maybe someone has already asked your question
- Haskell on Reddit
- How I Start: Haskell - How to set-up a new Haskell project
#haskelland#haskell-beginners- IRC channels on freenode