Portland Functional Programming Study Group

pdxfunc is a study/user group exploring the world of functional programming, based in Portland, Oregon. The group welcomes programmers interested in all functional languages, including Haskell, Lisp, OCaml, and others. The group has been meeting regularly since November 2007 for presentations, demos and discussions applicable to all skill levels, from newbies and experts. Every month 15-35 people come together to share their knowledge, projects and enthusiasm for functional programming – join us!

Participate

There are many ways to participate in pdxfunc:

  • Attend our meetings, they are usually on the second Monday of the month. If you have presentations, discussion topics or activities you would like to see, please post them to the mailing list or mention them at the beginning of meetings.
  • Subscribe to our online mailing list to receive meeting announcements and notes, get suggestions of interesting events, and participate in technical discussions. You may post jobs and gigs for FP-related work within ~100 miles of Portland.
  • Follow us on Twitter for meeting announcements and notes.
  • Join us on Freenode IRC: #pdxfunc
  • Join us on ePDX to tell the world that you're part of this user group and find others.

Other local groups

  • pdxlang - Zissou Society for Programming Language Exploration
  • pdxscala - Portland Scala users group
  • pdxerlang - Erlang users group
  • clojerks - Clojure users group

This month's meeting

“Effects tracking shoot-out”: Justin Bailey and Leif Warner will compare two different approaches for tracking effects in pure code proposed by Oleg Kiselyov and Edwin Brady, respectively. Justin will be presenting based off the approach described in Oleg's paper “Extensible Effects – An Alternative to Monad Transformers” implemented in Haskell, while Leif will be presenting the DSL Edwin implemented in the Idris language.

“effects” are usually tracked in languages like Haskell with monads, and often combined with monad transformers. Both of these approaches aim for a more elegant alternative to monad transformers for this.

From the intro to Edwin's paper:

Monad transformers can quickly become unwieldy when
there are lots of effects to manage, leading to a temptation in
larger programs to combine everything into one coarse-grained
state and exception monad.

And the intro to Oleg's paper:

We design and implement a library that solves the long-standing problem of combining effects without imposing restrictions on their interactions (such as static ordering). Effects arise from interactions between a client and an effect handler (interpreter); interactions may vary throughout the program and dynamically adapt to execution conditions. Existing code that relies on monad transformers may be used with our library with minor changes, gaining efficiency over long monad stacks. In addition, our library has greater expressiveness, allowing for practical idioms that are inefficient, cumbersome, or outright impossible with monad transformers.
Our alternative to a monad transformer stack is a single monad, for the coroutine-like communication of a client with its handler. Its type reflects possible requests, i.e., possible effects of a computation. To support arbitrary effects and their combinations, requests are values of an extensible union type, which allows adding and, notably, subtracting summands. Extending and, upon handling, shrinking of the union of possible requests is reflected in its type, yielding a type-and-effect system for Haskell. The library is lightweight, generalizing the extensible exception handling to other effects and accurately tracking them in types.

http://calagator.org/events/1250466647/

Notes on Etherpad: http://etherpad.stumptownsyndicate.org/p/07-2014-pdxfunc

Notes from past meetings

Every pdxfunc meeting is full of awesome, but we often forget to take notes, so this is just a fraction of what we talk about in person. The most recent content is at the top:

  • Video and notes for “Haskell Records” by Nathan Collins; and “Designing a JSON Validator DSL” by Lyle Kopnicky.
  • Notes for “Actors with Oz” by Lyle Kopnicky; Haskell legacy code, testing, code coverage, static analysis, and pronunciation; Kotlin.
  • Notes for “Introduction to Oz”, a multi-paradigm programming language that incorporates many functional features by Lyle Kopnicky.
  • Notes for “Glome Ray Tracer” by Jim Snow; and Node.js and CoffeeScript by Merlyn Albery-Speyer.
  • Site for Vintage BASIC, a Haskell-based interpreter for the BASIC programming language by Lyle Kopnicky.
  • Notes for code spelunking with Yesod, QuasiQuote, Parsec and Template Haskell by Igal Koshevoy.
  • Notes for an “Overview of the Yesod web framework for Haskell” by Igal Koshevoy.
  • Notes for a “Yesod clone of git-http-backend” by Jamey Sharp and Josh Triplett.
  • Notes for “FRP, Functional Reactive Programming” by Jake Brownson.
  • Notes for “Curry: a Functional Language with Non-determinism” by Sergio Antoy and “KiCS2: A New Compiler from Curry to Haskell”]] by Michael Hanus.
  • Notes for Agda theorem prover by Julian Blake Kongslie; Serialist.net - lazy web-crawling in Haskell, FP webapps, early-finish monad, HTTP Digest, etc. by Jamey Sharp and Josh Triplett.
  • Notes for Data.Binary by Don Stewart; Data.Serialize by Trevor Elliot; Linux kernel modules in Haskell by Thomas DuBuisson; command-line argument parsing by Bart Massey; random, Control.Monad.Random by Julian Blake Kongslie; System.Random.Mersenne and Mersenne.Random.Pure64 by Don Stewart; and Motivik - music signal processing by Jeremy Voorhis.
  • Notes for “Designing, visualizing and benchmarking data structures in Haskell” by Don Stewart.
  • Notes for FRP - Functional Reactive Programming, Fran, Yampa, Arrows, and Monads vs. Arrows by Julian Blake Kongslie; Haskell $ operator, Type Classes and unit conversion in Haskell by Jesse Hallett.
  • Notes for Clojure and Cascade by Howard Lewis Ship.
  • Notes for “Handbook of Practical Logic and Automated Reasoning” by John Harrison.
  • Notes for “Beautiful Parallelism: Harnessing Multicores with Haskell” by Don Stewart.
  • Notes for “Trace-Based Just-In-Time Compilation For Highly-Dynamic Languages” by Jim Blandy.
  • Notes for thimk, a command-line Haskell spellchecker by Bart Massey; OCaml Batteries Included; Haskell Platform.
  • Notes for “The Haskell Cheatsheet” by Justin Bailey.
  • Notes for Computer Language Benchmarks Game on approaches to speeding up code using hints, cleverness, algorithms, multiple cores, etc.
  • Notes for “Why OOP is inherently a pile of fail” by Bart Massey, and “CHORTL - Combinator Haskell Operators for RTL” by Julian Kongslie Blake.
  • Notes for “Designing, visualizing and benchmarking data structures in Haskell” by Don Stewart
  • Notes for first meeting ever: philosophy, call for participation, resources, etc.