We wanted to spice things up a bit at NY-Scala, so with the inspiration of Emily Chen from meetup.com, we've decided to try something new'ish. This new'ish thing will be familiar to you if you've attended the Northeast Scala Symposium, as it shares some similarities with the "unconference" format that we follow on the second day of the conference. Essentially we'll be meeting informally to discuss "something interesting" in groups led by anybody who wants to lead one. This time, we'll take the lead to show how it's done, but we're hoping to make this a community driven thing going forward.

There will be three sessions taking inspiration from the great book, "Functional Programming in Scala" - a beginner, intermediate, and advanced session. We'll pitch our ideas before the sessions start, and then break up into groups and do whatever each organizer has planned. You ought to come with a laptop with sbt installed.

We may not get this right the first time, so we're going to try it a few times and hope others from the group will sign up to lead discussions at future (un)meetups! Here's an idea of what we plan to discuss:

BEGINNER

Emily will go over the topics discussed in Chapters 1 & 2 of the book.

Why Functional Programming?

What is a function and why do we care?

How to use referential transparency to reason about programs

Intro to FP in Scala

Practice writing higher-order functions with generics

Afterwards, everyone will have time to work on the programming exercises in Chapters 1 & 2. There will be opportunities to pair program.

INTERMEDIATE

Doug will be discussing the "Error Handling Without Exceptions" chapter of the book. Functional programmers tend to think that functions should return values, not just return them most of the time and completely bomb on occasion. Doug will walk through several different ways of handling exceptions as data and how to include them in intuitive ways in return values. There may even be an explanation or two of what an Applicative Functor is compared to a Monad, and why that might be a useful thing to know and look out for. There will also be some time to go through some problems from this chapter in the book. There are many libraries for doing this, and Doug hasn't used them all, so hopefully some members of the community can share their preferences and experience.

ADVANCED

Monads. We'll start with some very simple Monads, and build up an intuition for how to recognize them in the wild, see how they are useful, look at some ugliness, and see how to get around it. Along the way we'll build the case for the Free Monad. We'll also show how to take some of the pain away from Free Monads with the open source library Freek (https://github.com/ProjectSeptemberInc/freek). @mandubian, Freek's author, will be in town and will be participating in this session, though it will be lead by Dustin.