Viewing 0 current events matching “pdxfunc” by Event Name.

Sort By: Date Event Name, Location , Default
No events were found.

Viewing 91 past events matching “pdxfunc” by Event Name.

Sort By: Date Event Name, Location , Default
Tuesday
Jul 23, 2013
Functional Programming meetup

With OSCON in town this week, bringing to town many from the functional programming community among others, we thought it would be a good idea to hold a casual functional programming meetup. There's no agenda and no talks, but there will be beer and good conversation.

We'll be meeting up on the patio at Green Dragon. If you're just visiting and are worried you won't recognize the geeks when you get there (we're usually easy enough to spot), feel free to ping people on the PDXFunc mailing list (https://groups.google.com/forum/#!forum/pdxfunc) or on IRC at #pdxfunc.

Monday
Jun 8, 2015
Functional Programming Study Group
Collective Agency Downtown

Levent Erkok will be giving an informal talk on the SBV library that he's been working on for quite some time now (https://hackage.haskell.org/package/sbv), and a possible brief intro to SAT/SMT solving.

Website
Tuesday
Sep 2, 2008
Galois Tech Talk: GpuGen: Bringing the Power of GPUs into the Haskell World
Galois, Inc

Title: GpuGen: Bringing the Power of GPUs into the Haskell World

Speaker: Sean Lee

       Programming Languages & Systems
       UNSW, Sydney

Date: Tuesday, September 2nd.

       10.30am

Location: Galois, Inc.

       421 SW 6th Ave. Suite 300
       (3rd floor of the Commonwealth Building)
       Portland, Oregon

Abstract:

For the last decade, the performance of GPUs has out-grown CPUs, and their programmability has also improved to the level where they can be used fo general-purpose computations. Nonetheless, GPU programming is still limited only to those who understand the hardware architecture and the parallel processing. This is because the current GPU programming systems are based on the specialized parallel processing model, and require low-level attention in many aspects such as thread launching and synchronization.

The need for a programming system which provides a high-level abstraction layer on top of the GPU programming systems without losing the performance gain arises to facilitate the use of GPUs. Instead of writing a programming system from the scratch, the development of a Haskell extension has been chosen as the ideal approach, since the Haskell community has already accumulated a significant amount of research and resources for Nested Data Parallelism, which could be adopted to provide a high-level abstraction on GPU programming and even to broaden the applicability of GPU programming. In addition, the Foreign Function Interface of Haskell is sufficient to be the communication medium to the GPU.

GpuGen is what connects these two dots: GPUs and Haskell. It compiles the collective data operations such as scan, fold, map, etc, which incur most computation cost, to the GPU. The design of the system, the structure of the GpuGen compiler, and the current development status are to be discussed in the talk.

Biographical details:

Sean Lee is a PhD candidate at the UNSW, Sydney, working in the Programming Languages & Systems Group. This summer he's been interning at Nvidia in Santa Clara, working on programming GPUs with Haskell.

About the Galois Tech Talks.

Galois (http://galois.com) has been holding weekly technical seminars for several years on topics from functional programming, formal methods, compiler and language design, to cryptography, and operating system construction, with talks by many figures from the programming language and formal methods communities.

The talks are open and free. If you're planning to attend, dropping a note to [email protected] is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers.

Website
Tuesday
Sep 9, 2008
Galois Tech Talk: Pretty-Printing a Really Long Formula (or, "What a Mathematician Could Learn from Haskell")
Galois, Inc

TITLE: Pretty-Printing a Really Long Formula (or, "What a Mathematician Could Learn from Haskell")

SPEAKER: Lee Pike, R&D Engineering, Galois, Inc.

DATE: Tuesday, September 9th. 10.30am

LOCATION:
Galois, Inc. 421 SW 6th Ave. Suite 300 (3rd floor of the Commonwealth Building) Portland, Oregon

ABSTRACT:

To the typical engineer or evaluator, mathematics can be scary, logic can be scarier, and really long specifications can simply be overwhelming. This talk is about the problem of the visual presentation of formal specifications clearly and concisely. We take as our initial inspiration Leslie Lamport's brief paper, "How to Write a Long Formula" and "How to Write a Proof" in which he proposes methods for writing the long and tedious formulas and proofs that appear in formal specification and verification.

I will describe the problem and present one particular solution, as implemented in a simple pretty-printer I've written (in Haskell), that uses indentation and labels to more easily visually parse long formulas. Ultimately, I propose a "HOL Normal Form" for presenting specifications, much like BNF is used for presenting language definitions.

BIOGRAPHICAL DETAILS:

http://galois.com/company/people/lee_pike/

ABOUT THE GALOIS TECH TALKS.

Galois (http://galois.com) has been holding weekly technical seminars for several years on topics from functional programming, formal methods, compiler and language design, to cryptography, and operating system construction, with talks by many figures from the programming language and formal methods communities.

The talks are open and free. If you're planning to attend, dropping a note to [email protected] is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers.

Tuesday
Oct 7, 2008
Galois Tech Talk: The Future of Cabal (Haskell package management)
Galois, Inc

Duncan Coutts, from Well-Typed (http://well-typed.com), will be giving a tech talk tomorrow about the technical direction of Cabal, Haskell package infrastructure, and the problems of managing very large amounts of Haskell code.

...

TITLE: The Future of Cabal -- "A language for build systems" and "Constraint solving problems in package deployment"

SPEAKER: Duncan Coutts, Well-Typed, LLP

DATE: Tuesday, Oct 7, 2008 10.30am

LOCATION: Galois, Inc. 421 SW 6th Ave. Suite 300 (3rd floor of the Commonwealth Building) Portland, Oregon

ABSTRACT:

This will be an informal talk and discussion on two topics:

  1. A language for build systems

Build systems are easy to start but hard to get right. We'll take the view of a language designer and look at where our current tools fall down in terms of safety/correctness and expressiveness.

We'll then consider some very early ideas about what a build system language should look like and what properties it should have. Currently this takes the form of a design for a build DSL embedded in Haskell.

  1. Constraint solving problems in package deployment

We are all familiar, at least peripherally, with package systems. Every Linux distribution has a notion of packages and most have high level tools to automate the installation of packages and all their dependencies. What is not immediately obvious is that the problem of resolving a consistent set of dependencies is hard, indeed it is NP-complete. It is possible to encode 3-SAT or Sudoku as a query on a specially crafted package repository.

We will look at this problem in a bit more detail and ask if the right approach might be to apply our knowledge about constraint solving rather than the current ad-hoc solvers that most real systems use. My hope is to provoke a discussion about the problem.

We can concentrate on one topic or the other depending on peoples interest.

ABOUT THE GALOIS TECH TALKS:

Galois (http://galois.com) has been holding weekly technical seminars for several years on topics from functional programming, formal methods, compiler and language design, to cryptography, and operating system construction, with talks by many figures from the programming language and formal methods communities.

The talks are open and free. If you're planning to attend, dropping a note to [email protected] is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers.

Website
Tuesday
Sep 16, 2008
Galois Tech Talk: Theorem Proving for Verification
Galois, Inc

Title: Theorem Proving for Verification

Speaker: John Harrison

        Principal Engineer
        Intel

Date: Tuesday, September 16th.

        10.30am

Location: Galois, Inc.

        421 SW 6th Ave. Suite 300
        (3rd floor of the Commonwealth Building)
        Portland, Oregon

Abstract:

The theorem proving approach to verification involves modelling a system in a rich formalism such as higher-order logic or set theory, then performing a human-driven interactive correctness proof using a proof assistant. In a striking contrast, techniques like model checking, by limiting the user to a less expressive formalism (propositional logic, CTL etc.), can offer completely automated decision methods, making them substantially easier to use and often more productive.

With this in mind, why should one be interested in the theorem proving approach? In this tutorial I will explain some of the advantages of theorem proving, showing situations where the generality of theorem proving is beneficial, allowing us to tackle domains that are beyond the scope of automated methods or providing other important advantages. I will talk about the state of the art in theorem proving systems and and give a little demonstration to give an impression of what it's like to work with such a system.

Biographical details:

John Harrison has worked in formal verification and automated theorem proving since 1990, when he joined Mike Gordon's "Hardware Verification Group" (HVG) at the University of Cambridge Computer Laboratory. As well as working on the development of the HOL theorem prover, he developed a particular interest in the formalization of real analysis and its application to formal verification of floating-point hardware. His PhD in this area, "Theorem Proving with the Real Numbers", written under Mike Gordon's supervision, won a UK Distinguished Dissertation award and was published as a book. He also redesigned HOL from scratch, resulting in an alternative version called HOL Light. After completing his PhD research in 1995, John Harrison spent a very enjoyable year at Abo Akademi University and Turku Centre for Computer Science (TUCS) in Turku, Finland, where he was a member of Ralph Back's Programming Methods Research Group. Among other activities, he championed the "declarative" proofs of the Mizar system and showed how these could be integrated into other theorem-provers, work subsequently taken up in DECLARE, Isar and other systems.

John Harrison then returned to Cambridge and worked on a formal model of floating-point arithmetic and its application to the verification of some realistic algorithms for transcendental functions. This work attracted the attention of Intel, and in 1998 John Harrison joined the company as a Senior Software Engineer (now Principal Engineer) specializing in the design and formal verification of mathematical algorithms. He has formally verified and in many cases designed or redesigned numerous algorithms for mathematical functions including division, square root and transcendental functions.

In his limited spare time over the past 10 years, John Harrison has been working on a book giving a comprehensive introduction to automated theorem proving.  (http://www.cambridge.org/9780521899574)

About the Galois Tech Talks.

Galois (http://galois.com) has been holding weekly technical seminars for several years on topics from functional programming, formal methods, compiler and language design, to cryptography, and operating system construction, with talks by many figures from the programming language and formal methods communities.

The talks are open and free. If you're planning to attend, dropping a note to <[email protected]> is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers.
Tuesday
Oct 14, 2008
Galois Tech Talk: Type Correct Changes, A Safe Approach to Version Control Implementation
Galois, Inc

Next week's tech talk, a special treat, with Jason Dagit (aka. lispy on

haskell) dropping by to talk about using GADTs to clean up darcs' patch

theory implementation.


TITLE: Type Correct Changes A Safe Approach to Version Control Implementation

speaker: Jason Dagit

LOCATION: Galois, Inc. 421 SW 6th Ave. Suite 300 (3rd floor of the Commonwealth Building) Portland, Oregon

ABSTRACT:

This will be a talk about Darcs and type safe manipulations of changes:

Darcs is based on a data model, known as Patch Theory, that sets it apart from other version control systems. The power of this data model is that it allows Darcs to manage significant complexity with a relatively straightforward user interface.

We show that Generalized Algebraic Data Types (GADTs) can be used to express several fundamental invariants and properties derived from Patch Theory. This gives our compiler, GHC, a way to statically enforce our adherence to the essential rules of our data model.

Finally, we examine how these techniques can improve the quality of the darcs codebase in practice.

PRESENTER:

Jason Dagit graduated from Oregon State University with B.S. degrees in Computer Science and Mathematics. He is currently employed at PTV America while completing his Masters degree at Oregon State under co-advisors Dr. David Roundy and Dr. Martin Erwig. During his time in graduate school he has studied both usability and programming languages. He participated in the 2007 Google Summer of Code where he worked under Dr. Roundy to improve Darcs conflict handling.

ABOUT THE GALOIS TECH TALKS:

Galois (http://galois.com) has been holding weekly technical seminars for several years on topics from functional programming, formal methods, compiler and language design, to cryptography, and operating system construction, with talks by many figures from the programming language and formal methods communities.

The talks are open and free. If you're planning to attend, dropping a note to [email protected] is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers.

Website
Monday
Sep 15, 2008
Galois Tech Talks: Left-fold enumerators -- Towards a safe, expressive and efficient I/O interface for Haskell
Galois, Inc

Title: Left-fold enumerators

        Towards a safe, expressive and efficient I/O interface for Haskell

Speaker: Johan Tibell

        Software Engineer
        Google

Date: Monday, September 15th.

        1pm

Location: Galois, Inc.

        421 SW 6th Ave. Suite 300
        (3rd floor of the Commonwealth Building)
        Portland, Oregon

Abstract:

I will describe a programming style for I/O operations that is based on left-fold enumerators. This style of programming is more expressive than imperative style I/O represented by the Unix functions read and write, and safer than lazy I/O using streams. Left-fold enumerators offers both high-performance using block based I/O and safety in terms of error handling and resource usage. I will demonstrate Hyena, a web server prototype written in Haskell, as an example of left-fold enumerator style of programming.

This talk is intended as a starting point for further discussions on what would be a good interface for I/O rather than a presentation of finished research.

About the Galois Tech Talks.

Galois (http://galois.com) has been holding weekly technical seminars for several years on topics from functional programming, formal methods, compiler and language design, to cryptography, and operating system construction, with talks by many figures from the programming language and formal methods communities.

The talks are open and free. If you're planning to attend, dropping a note to  is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers.

Thursday
Oct 2, 2008
Galois Tech: Advanced Modeling, Design and Verification using High-Level Synthesis
Galois, Inc

Title: Bluespec: Advanced Modeling, Design and Verification using High-Level Synthesis Speaker: Rishiyur Nikhil CTO, Bluespec, Inc. Date: Thursday, October 2nd. 10.30am Location: Galois, Inc., 421 SW 6th Ave. Suite 300, (3rd floor of the Commonwealth Building)

ABSTRACT:

Over the past few years, several projects in major companies have been adopting BSV (Bluespec SystemVerilog) as their next-generation tool of choice for IP design, modeling (for both architecture exploration and early software development), and verification enviroments.

The reason for choosing BSV is its unique combination of:

(1) excellent computation model for expressing complex concurrency and communication, based on atomic transactions and atomic transactional inter-module methods

(2) very high level of abstraction and parameterization (principally inspired by Haskell)

(3) full synthesizability, enabling execution on FPGAs, obtaining better performance (3 to 4 orders of magnitude) and scalability than software simulation at comparable levels of detail.

In this presentation, I will provide a brief technical overview of BSV (points 1-3 above), and describe several customer projects using BSV. I will also briefly contrast BSV with other approaches to High Level Synthesis (particularly those based on C/C++/SystemC).

BIOGRAPHY:

Rishiyur S. Nikhil is co-founder and CTO of Bluespec, Inc., which develops tools that dramatically improve correctness, productivity, reuse and maintainability in the design, modeling and verification of digital designs (ASICs and FPGAs). The core technologies consist of a language, BSV (Bluespec SystemVerilog), which enables very abstract source descriptions based on scalable atomic transactions and extreme parameterization, and tools for high-quality synthesis of BSV into RTL. Earlier, from 2000 to 2003, he led a team inside Sandburst Corp. (later acquired by Broadcom) developing Bluespec technology and contributing to 10Gb/s enterprise network chip models, designs and design tools.

From 1991 to 2000 he was at Cambridge Research Laboratory (DEC/Compaq), including one and a half years as Acting Director. From 1984 to 1991 he was a professor of Computer Science and Engineering at MIT. He has led research teams, published widely, and holds several patents in functional programming, dataflow and multithreaded architectures, parallel processing, compiling, and EDA. He is a member of ACM and IFIP WG 2.8 on Functional Programming, and a Senior Member of IEEE. He received his Ph.D. and M.S.E.E. in Computer and Information Sciences from the Univ. of Pennsylvania, and his B.Tech in EE from IIT Kanpur.

ABOUT THE GALOIS TECH TALKS:

Galois (http://galois.com) has been holding weekly technical seminars for several years on topics from functional programming, formal methods, compiler and language design, to cryptography, and operating system construction, with talks by many figures from the programming language and formal methods communities.

The talks are open and free. If you're planning to attend, dropping a note to [email protected] is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers.

Website
Friday
Sep 25, 2009
HacPDX: Portland Haskell Hackathon
through Portland State University FAB, Room 86-09

HacPDX is an opportunity to join Portland Haskell hackers in building and improving Hackage libraries and tools. If you've never been, Hackathons are typically not only a good opportunity for experienced devs to work together but also a great way for newcomers to get involved in the community.

Visit this website for complete details: http://www.haskell.org/haskellwiki/HacPDX

Website
Thursday
Apr 30, 2009
ICFP PC Functional Programming Workshop
Portland State University (PSU) - Smith Memorial Center

Room: Portland State University, The Vanport Room (rm 338), Smith Memorial Student Union. The building is at Harrison and Broadway; enter via door on Harrison and take stairs to 3rd floor.

Content: Series of presentations by distinguished members of the FP community from around the world:

  • Algebra of Programming using Dependent Types. Shin-Cheng Mu (Academia Sinica)
  • Realizability Semantics of Parametric Polymorphism, General References, and Recursive Types. Lars Birkedal (IT University of Copenhagen)
  • A Compiler on a Page. Kristoffer Rose (IBM Thomas J. Watson Research Center)
  • A Proof Theory for Compilation. Atsushi Ohori (Tohoku University)
  • Data Parallelism in Haskell. Manuel Chakravarty (University of New South Wales)
  • Push-down control-flow analysis of higher-order programs. Matthew Might (University of Utah)
  • Slicing It: indexed containers in Haskell. Conor McBride (University of Strathclyde)
  • Daan Leijen (Microsoft Research)
  • Koen Claessen (Chalmers University of Technology)
  • Taking the monad laws seriously. Andrzej Filinski (University of Copenhagen)
  • A compiler front-end for Mini-ML and its Coq proof of correctness. Xavier Leroy (INRIA Paris-Rocquencourt)
Website
Friday
Jun 6, 2014
Idris (dependently-typed lang) meetup with Edwin Brady
Lucky Labrador Beer Hall

Idris is a dependently typed language that looks pretty much like Haskell with depedent types.

Its creator, Edwin Brady will be in town this Friday, and says he can give an impromptu talk or demo on some of his latest work in the language.

Come get your copy of the Idris compiler autographed!

Website
Monday
Mar 10, 2014
PdxFunc
Rentrak - Downtown

Speakers: Jake Brownson, Leif

Hope to see you there!

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Sep 8, 2008
pdxfunc monthly meeting
CubeSpace [ *sniff* out of business 12 June 2009]

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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jun 11, 2012
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jul 9, 2012
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

PRESENTATIONS:

  • Lyle Kopnicky will present the design of a DSL for validating JSON structures from Janrain. It's in Ruby, but functional-inspired.
  • Nathan Collins will present on a core language for better records in Haskell. These primitives build a record system with a nice surface language syntax that offers benefits over the traditional Haskell records: first-class records, reusable field names, row polymorphism, direct setting/modifying nested fields, extensible records, polymorphic updates, etc.
  • ...and more!

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Aug 13, 2012
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

Talks:

  • Thomas Lockney will talk about how Scala's Akka fits into the functional programming environment (e.g. using futures to compose interactions with actors), and how actors can be used in Akka to do things usually delegated to external middleware.
  • ...and more!

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Sep 10, 2012
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

PRESENTATIONS:

  • Lyle Kopnicky will compare and contrast functional reactive programming (FRP) with Max, the visual programming environment for music and video. They exist in the generally distinct worlds of computer science academia and professional production of live music and video. He will also touch on two FRP systems, FrTime and Yampa, as they are very different, but together illustrate the variations on FRP.

  • Philip Weaver will talk about performance tuning in Haskell. Laziness in Haskell can lead to performance that is very poor and difficult to understand. He will discuss a recent experience where memory consumption in a TLS implementation was about 100x the expected amount, how he used the GHC profiler to diagnose the problem, and how he used mutable variables and low-level GHC primitives to optimize the algorithm.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

SPONSORS: This meeting's venue, food and drinks are kindly sponsored by Janrain, providers of hosted user management solutions for social login and sharing, single sign-on and social profile storage: http://www.janrain.com/

Website
Monday
Oct 8, 2012
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

PRESENTATIONS

  • Matt Youell will talk about some of the functional features of C#
  • Echo Nolan will talk about functional reactive programming (FRP) and the reactive-banana library for Haskell. More specifically, a series of worked examples in audio synthesis will be explored, showing the expressive power of FRP; hopefully positively answering the questions: "What can FRP do for me?" and "Why should I bother learning yet another abstraction?"
  • Lyle Kopnicky will present "SKI School: The Combinator Calculus Demystified", covering the SKI-calculus, Peano and Church numerals, and Iota. Fun math games!
  • ...and a lot more!

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Nov 12, 2012
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

This meeting is pdxfunc's 5 year anniversary. There will be food, drink and cake1. You're welcome to bring other tasty things to share. We'll have utensils, napkins and plates available.

PRESENTATIONS

  • Bart Massey and Jamey Sharp will talk about the bidirectional superfold, demonstrating the power of lazy programming with Haskell.
  • Jesse Hallett will talk about implementing the state monad in JavaScript.
  • Echo Nolan will talk about the Haskell "numbers" package.
  • ...and much more!

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

1 The cake is a lie.

Website
Monday
Dec 10, 2012
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

PRESENTATIONS:

  • Paul deGrandis on Clojure data structures and reducers. Reducers are based on monoids and protocols, and automatically parallelize folding and mapping on sequences/collections.
  • Leif Warner on Idris, a general purpose pure functional programming language with dependent types. "Idris is a language perhaps between Haskell and Scala, but with dependent types. For the most part it looks much like Haskell, only types and values share the same namespace. Other features it offers are things like a simple FFI to C, idiom brackets, and extensible syntax."
  • ...and much more!

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jan 14, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

PRESENTATIONS:

  • Lyle Kopnicky will present the "Scrap Your Boilerplate" library for generic programming in Haskell.
  • Bart Massey will talk about his work-in-progress project for Minecraft data management tools in Haskell, assuming he can get downtown given the weather.
  • ...and more!

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Feb 11, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

Please note new location: Larger space on the 4th floor this time, not 6th floor.

Joe Hurd can give a tutorial-like talk on an optimization technique for functional programs that he calls explicit laziness. And then we can talk about anything else people would like to discuss.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

λ

Website
Monday
Mar 11, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
May 13, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

Luc Perkins has offered to give a talk "Pandoc: the deep dive." - an exploration of how Pandoc works its magic, and why FP is a good choice for that kind of project.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jun 10, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jul 8, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Aug 12, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

This month we're happy to have Carl Howells presenting "A Tale of Two Libraries, or How Recent GHC Features Make Type Hackery Easier Than API Design", stemming from his recent work on a haskell library using many of the new type system features added in GHC 7.4 and 7.6. Topics will include type-level naturals and their reification via singleton types, lifted data types, kind polymorphism, and fiddly GHC details that make all these things slightly less awesome than they should be. Also included will be an object lesson in the dangers of naming and releasing too early.

Also, we'll have Lyle Kopnicky talking on "Just-in-Time Compilation in Haskell".

See you there!

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Sep 9, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters
  • Jim Snow will talk about polink.org, a reputation-based collaborative social site he's been working on, written in Haskell with the Yesod framework for the frontend, and acid-state for persistence. https://github.com/jimsnow/polink

  • Jesse Hallett will talk about Mori, a library that ports functional data structures from Clojure / ClojureScript to JavaScript. https://github.com/swannodette/mori

Hope to see you there!

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Oct 14, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

See the mailing list for details on this month's agenda: https://groups.google.com/d/msg/pdxfunc/Z7ReDe0NECQ/QUKKFz-Id6MJ

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Nov 11, 2013
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

Jake Brownson will be presenting on his project River:

River is a purely functional reactive system built on top of C++11 with some Ruby metaprogramming. It's reactive in the sense that as inputs to the program change invalidations ripple through a big graph of functions until they hit the outputs which greedily reevaluate the graph. One significant difference from other reactive systems is that there is no notion of time, or sequences of values at the language level. There is no notion of events, or continuous streams of values. It is just a big function that gets reevaluated as the input changes. We can talk about these things using the system, but they aren't first class.

One key idea is to push all of the logical state out of the program itself and just make the outputs a big function of the inputs to the program. One big function.

Inputs to the program can be things like the total console input as a list of characters, a list of clicks the user has made, etc. Outputs of the program are things like "There should be a window on screen" "The window should be called 'Frank'", "The window should have this button on it", etc. When the user clicks a button in the window the inputs change and a new output is calculated. Maybe the window is now called "Bob". Maybe the window no longer is on screen, but there's no state in the program that isn't a function of the inputs.

Interactive Haskell programs work by ultimately evaluating some lazy list of things that doesn't end until the program is terminated. They're always in a state of being partially evaluated until the program ends. In each invalidation cycle the River program is fully evaluated, but the bits of it that are dependent on inputs that could change stay in memory so they can respond to changing inputs. An input list may have been empty the first go around, but now it has an item in it.

I'm building River as the first phase of a larger project, but would be a whole different talk that hopefully I'll be able to do some day when I have something to demo. I'm always happy to rant about it if you ask though :).

If the group is interested I would be showing an AppKit GUI implementation of the logic puzzle Akari running in the system and digging in to how things work a bit (don't worry, I won't show the particularly crazy c++ bits). I'll also show an interactive visualization of the in-memory graph that allows you to navigate it hierarchically which makes a great debugging tool.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jan 13, 2014
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

Jim Snow will give a short presentation on some Haskell code he wrote to explore just intonation tuning systems. He uses this to figure out where to to put the frets on some just intonation guitars he's built, among other things.

Additionally, whatever other topics people bring up for discussion between now and then are welcome, too!

See the mailing list for details on this month's agenda: https://groups.google.com/forum/#!forum/pdxfunc

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Feb 10, 2014
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

See the mailing list for details on this month's agenda: https://groups.google.com/forum/#!forum/pdxfunc

Jake Brownson will report on the experience of implementing both an Akari logic puzzle solver and generator in both Clojure and Haskell. Some discussion will be had, and hopefully he'll get some questions answered.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Apr 14, 2014
pdxfunc: Portland Functional Programming Study Group
Urban Airship Inc

This month Jamey Sharp is presenting his work on the "process calculus" language LOTOS, specically, a compiler written in Haskell.

I've been working on a Haskell compiler for a language called LOTOS over the last two weeks, and I'd like to share its implementation with the group. It generates event-driven imperative code from a "process calculus" language (distant cousin to the concurrency model of Erlang or Go).

My goal is to make the presentation accessible for folks who don't have a compilers background, and introduce some Haskell tricks folks may not have seen. With help from the audience I think we can do this. That said, someone should tell me how short to keep the talk because I've probably spent 100 hours writing the code and could fill a good fraction of that explaining it.

You can follow my progress on GitHub:

https://github.com/jameysharp/lotos

Check out the README for notes on the device driver synthesis language that inspired me to start this project, a high-level description of the compilation strategy I've taken, and possible future directions for the project.

Also if there's time, Jim Snow will present on his Glome ray tracer written in Haskell:

I've been working on Glome lately, and it's probably about time I gave another short talk about it.

Glome is a ray tracer written in Haskell. It has a few nice features, such as a pretty good acceleration structure (basically, a hierarchical tree of bounding volumes) so that rendering complex scenes goes pretty fast, CSG support (you can subtract one volume from another or take the intersection of multiple volumes) and a decent set of basic primitives.

Some recent changes are more general types for textures (basically, you can define your own lighting model) and the ability to place arbitrary tags on objects so that when you trace a ray, you get back a list of tags that you can use to identify the thing (or things) that a ray hit. Hopefully, this will make Glome a lot more useful for general computational geometry tasks and for interactive applications. (Glome is still too slow to be a serious competitor to OpenGL, but it's at least approaching the point where rendering in realtime is almost tolerable.)

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
May 12, 2014
pdxfunc: Portland Functional Programming Study Group
Urban Airship Inc

Jim Snow will present on his Glome ray tracer written in Haskell:

I've been working on Glome lately, and it's probably about time I gave another short talk about it.

Glome is a ray tracer written in Haskell. It has a few nice features, such as a pretty good acceleration structure (basically, a hierarchical tree of bounding volumes) so that rendering complex scenes goes pretty fast, CSG support (you can subtract one volume from another or take the intersection of multiple volumes) and a decent set of basic primitives.

Some recent changes are more general types for textures (basically, you can define your own lighting model) and the ability to place arbitrary tags on objects so that when you trace a ray, you get back a list of tags that you can use to identify the thing (or things) that a ray hit. Hopefully, this will make Glome a lot more useful for general computational geometry tasks and for interactive applications. (Glome is still too slow to be a serious competitor to OpenGL, but it's at least approaching the point where rendering in realtime is almost tolerable.)

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jun 9, 2014
pdxfunc: Portland Functional Programming Study Group
Urban Airship Inc

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jul 14, 2014
pdxfunc: Portland Functional Programming Study Group
Urban Airship Inc

"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.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Aug 11, 2014
pdxfunc: Portland Functional Programming Study Group

See the mailing list for details on this month's agenda: https://groups.google.com/forum/#!forum/pdxfunc

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Sep 8, 2014
pdxfunc: Portland Functional Programming Study Group
Urban Airship Inc

See the mailing list for details on this month's agenda: https://groups.google.com/forum/#!forum/pdxfunc

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Oct 13, 2014
pdxfunc: Portland Functional Programming Study Group
Urban Airship Inc

This month we get to have David Christiansen, the main developer of Idris after Edwin himself, reprise his presentation from this year's Symposium on Implementation and Application of Functional Languages: "Type-Directed Elaboration of Quasiquotations: A High-Level Syntax for Low-Level Reflection." This enables using the user-visible surface syntax of the language for working with compile-time metaprogramming on reflected terms.

More information can be found at: http://www.davidchristiansen.dk/2014/08/20/new-paper-submission-type-directed-elaboration-of-quasiquotations-a-high-level-syntax-for-low-level-reflection/

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Nov 10, 2014
pdxfunc: Portland Functional Programming Study Group
Rentrak - Downtown

See the mailing list for details on this month's agenda: https://groups.google.com/forum/#!forum/pdxfunc

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Sunday
Dec 7, 2014
pdxfunc: Portland Functional Programming Study Group
Janrain Headquarters

Jake Brownson will be presenting on his project River:

River is a purely functional reactive system built on top of C++11 with some Ruby metaprogramming. It's reactive in the sense that as inputs to the program change invalidations ripple through a big graph of functions until they hit the outputs which greedily reevaluate the graph. One significant difference from other reactive systems is that there is no notion of time, or sequences of values at the language level. There is no notion of events, or continuous streams of values. It is just a big function that gets reevaluated as the input changes. We can talk about these things using the system, but they aren't first class.

One key idea is to push all of the logical state out of the program itself and just make the outputs a big function of the inputs to the program. One big function.

Inputs to the program can be things like the total console input as a list of characters, a list of clicks the user has made, etc. Outputs of the program are things like "There should be a window on screen" "The window should be called 'Frank'", "The window should have this button on it", etc. When the user clicks a button in the window the inputs change and a new output is calculated. Maybe the window is now called "Bob". Maybe the window no longer is on screen, but there's no state in the program that isn't a function of the inputs.

Interactive Haskell programs work by ultimately evaluating some lazy list of things that doesn't end until the program is terminated. They're always in a state of being partially evaluated until the program ends. In each invalidation cycle the River program is fully evaluated, but the bits of it that are dependent on inputs that could change stay in memory so they can respond to changing inputs. An input list may have been empty the first go around, but now it has an item in it.

I'm building River as the first phase of a larger project, but would be a whole different talk that hopefully I'll be able to do some day when I have something to demo. I'm always happy to rant about it if you ask though :).

If the group is interested I would be showing an AppKit GUI implementation of the logic puzzle Akari running in the system and digging in to how things work a bit (don't worry, I won't show the particularly crazy c++ bits). I'll also show an interactive visualization of the in-memory graph that allows you to navigate it hierarchically which makes a great debugging tool.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Feb 9, 2015
pdxfunc: Portland Functional Programming Study Group
Collective Agency Downtown

See the mailing list for details on this month's agenda. Attendance is limited at this venue. RSVP via the Meetup group.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Lisp, Clojure, Scala, Oz, Agda, Idris, and others. The group meets regularly on the second Monday of the month for presentations, demos and discussions applicable to all skill levels, from newbies and experts.

Website
Monday
Mar 9, 2015
pdxfunc: Portland Functional Programming Study Group
Collective Agency Downtown

See the mailing list for details on this month's agenda. Attendance is limited at this venue. RSVP via the Meetup group.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Lisp, Clojure, Scala, Oz, Agda, Idris, and others. The group meets regularly on the second Monday of the month for presentations, demos and discussions applicable to all skill levels, from newbies and experts.

Website
Monday
Apr 13, 2015
pdxfunc: Portland Functional Programming Study Group
Collective Agency Downtown

We have some interesting content lined up this month: Robert Dodier, a developer and project administrator on the Maxima project, has offered to give us a talk on it. Maxima is a computer algebra system written in Common Lisp. http://en.wikipedia.org/wiki/Maxima_(software)

Also, time permitting, we'll hear about Haskell and Clojure versions of small command-line programs, such as one for parsing and displaying data from a weather API.

See the mailing list for details on this month's agenda. Attendance is limited at this venue. RSVP via the Meetup group.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Lisp, Clojure, Scala, Oz, Agda, Idris, and others. The group meets regularly on the second Monday of the month for presentations, demos and discussions applicable to all skill levels, from newbies and experts.

Website
Monday
May 11, 2015
pdxfunc: Portland Functional Programming Study Group
Collective Agency Downtown

Hoping to hear about Haskell and Clojure versions of small command-line programs, such as one for parsing and displaying data from a weather API.

See the mailing list for details on this month's agenda. Attendance is limited at this venue. RSVP via the Meetup group.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Lisp, Clojure, Scala, Oz, Agda, Idris, and others. The group meets regularly on the second Monday of the month for presentations, demos and discussions applicable to all skill levels, from newbies and experts.

Website
Thursday
Apr 18, 2013
pdxfunc: Portland Functional Programming Study Group - Igal Rememberance Edition
Lucky Labrador Brew Pub

This meeting we've decided to meet at our old haunt, the back room of the SE Lucky Lab, remembering our awesome group organizer Igal, who hosted the group since its inception in 2007, but tragically left us last week. Come talk to others who knew him, members of of functional programming community, share stories, commiserate, have a drink.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, OCaml, Erlang, Scala and others, as well as using functional techniques in non-functional languages. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Dec 8, 2008
Portland Functional Programmers Study Group
CubeSpace [ *sniff* out of business 12 June 2009]

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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Jim Blandy will present trace-based just-in-time compilation techniques, how they're being used in his work at Mozilla with the SpiderMonkey JavaScript implementation, and how these can be applied to functional programming languages. Jim is a contributor to GNU Emacs, Guile, GDB, EGLIBC, Mozilla SpiderMonkey, Subversion, and others.

Website
Monday
Jan 12, 2009
Portland Functional Programmers Study Group
CubeSpace [ *sniff* out of business 12 June 2009]

Julian Blake Kongslie will present an introduction to state-space search, followed by some examples of various search methods in Haskell, with examples of both how to use search and how to write search code.

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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Mar 9, 2009
Portland Functional Programmers Study Group meeting
CubeSpace [ *sniff* out of business 12 June 2009]

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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
May 11, 2009
Portland Functional Programmers Study Group: OCaml-based automated theorem-proving
CubeSpace [ *sniff* out of business 12 June 2009]

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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

An OCaml-based automated theorem-proving textbook

John Harrison, Intel Corporation

My recently published "Handbook of Practical Logic and Automated Reasoning" ( http://www.cambridge.org/9780521899574 ) is a textbook on automated theorem proving with the unusual feature that all the techniques described are accompanied by actual OCaml source code ( http://www.cl.cam.ac.uk/~jrh13/atp/ ) that the reader can use, modify and otherwise experiment with. I believe that this kind of concrete hands-on approach has significant benefits for many fields of mathematics and computer science, and particularly for the area of automated theorem proving. Indeed, the original ML was specifically designed as an implementation and interaction language (hence Meta Language) for a theorem prover. In this talk I'll describe in more detail my rationale for writing the book in this way, provide a survey of the main contents and give a demo of some of the code.

John Harrison is a Principal Engineer at Intel Corporation, based in Hillsboro OR, specializing in formal verification, automated theorem proving, floating-point arithmetic and mathematical algorithms. He is also interested in the formalization of mathematics for its general intellectual interest and has formalized numerous classic theorems in his own HOL Light theorem prover (see http://www.cs.ru.nl/~freek/100/ ). Before joining Intel in 1998, he received his PhD from the University of Cambridge in England, supervised by Mike Gordon.

Website
Monday
Feb 9, 2009
Portland Functional Programmers Study Group: Wm Leler's Bertrand constraint language
CubeSpace [ *sniff* out of business 12 June 2009]

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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

This month, Wm Leler will talk about Constraint Satisfaction Systems and the Bertrand Programming Language. Wm is the creator of Bertrand and the author of the book "Constraint Programming Languages: Their Specification and Generation".

Constraint Satisfaction Systems were a hot topic of research in the 80's -- famous constraint systems include Ivan Sutherland's Sketchpad, Alan Borning's ThingLab (built on top of Smalltalk), Guy Steele's constraint language, and James Gosling's Magritte. These systems were used for computer graphics, design, and general numeric problem solving, but most of these solvers were domain specific and thus of limited usefulness.

Bertrand is an equational programming system whose purpose is to build constraint satisfaction systems using simple equational rules. Bertrand has an purely declarative semantics and an absurdly simple syntax, yet it is a powerful and expressive language, capable of solving problems in a large number of domains including graphics, word problems, electrical circuits, or -- with the right rules -- virtually any mostly-linear domain.

Since this is the Functional Programming Study Group, this talk will cover the underlying equational programming language of Bertrand and ways in which it could be extended to make it more powerful.

Website
Monday
Oct 13, 2008
Portland Functional Programming Study Group
CubeSpace [ *sniff* out of business 12 June 2009]

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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Apr 13, 2009
Portland Functional Programming Study Group
CubeSpace [ *sniff* out of business 12 June 2009]

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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jul 13, 2009
Portland Functional Programming Study Group
Lucky Labrador Brew Pub

Join programmers, researchers and enthusiasts to discuss functional programming.

We're meeting at the Lucky Labrador Brew Pub's event room this month, I'll post a sign on the door to guide you once there.

Please reply on the mailing list if you'd like to make a presentation or want to suggest a discussion topic for the meeting.

Possible talk and discussion ideas: * Exploring Lisp, Scheme or Clojure * Comparing Haskell Platform and OCaml BatteriesIncluded * Review and discuss some FP code, e.g. Kestrel, or some package in Cabal, etc * ...your great idea here!

See you soon!

Website
Monday
Aug 10, 2009
Portland Functional Programming Study Group
Lucky Labrador Brew Pub

Join programmers, researchers and enthusiasts to discuss functional programming.

Please reply on the pdxfunc mailing list if you'd like to make a presentation or want to suggest a discussion topic for the meeting.

Possible talk and discussion ideas: * Exploring Lisp, Scheme or Clojure * Comparing Haskell Platform and OCaml BatteriesIncluded * Review and discuss some FP code, e.g. Kestrel, or some package in Cabal, etc * ...your great idea here!

See you soon!

Website
Monday
Oct 12, 2009
Portland Functional Programming Study Group
NedSpace Old Town

Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: Space for the meeting is kindly provided by NedSpace, a co-working space for startups, innovative technology companies, non-profits, artists and social entrepreneurs.

Website
Monday
Dec 14, 2009
Portland Functional Programming Study Group
NedSpace Old Town

DISCUSSION TOPICS: * "Haskell Binary Parsing Showdown: Data.Serialize VS Data.Binary" by Trevor Elliott and Don Stewart. These two packages represent two ends of the spectrum for efficient parsing of binary, structured data in Haskell. The authors of both packages will show down describing the design and implementation, the benefits and the downsides. * "Control.Monad.Random" by Julian Blake Kongslie * "Linux Kernel Modules with Haskell" by Thomas DuBuisson * "Command-line argument/option parsing" by Bart Massey * "Unchecked unsafeCoerce and alternatives" by Thomas DuBuisson and Bart Massey

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: Space for the meeting is kindly provided by NedSpace, a co-working space for startups, innovative technology companies, non-profits, artists and social entrepreneurs.

Website
Monday
Jan 11, 2010
Portland Functional Programming Study Group
Roots Organic Brewing [Out of business. *Sigh*]

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: You can enter the event space through the glass doors on 7th that are close to the intersection with Clay, or through the front door and just look for signs to the event space. There will be pdxfunc signs on both.

PRESENTATIONS

  • "Serialist: Lazy web-crawling in Haskell" by Jamey Sharp and Josh Triplett

The http://serialist.net/ site provides a way to find, track and read serialized content (e.g., web comics). It's implemented entirely in Haskell and demonstrates functional web application development, crawling, scraping and distributed architecture. Serialist uses interesting graph algorithms to add and step through content lazily. Work on the site also produced useful, reusable Haskell modules: early-finish monad, HTTP Digest implementation, database layer, recursive monadic data structures, fast/lazy character converter, etc. Jamey and Josh will discuss these topics as well as their experiences analyzing and profiling their Haskell code to improve performance and reduce memory consumption.

  • Jamey Sharp's day job involves a computer test for attention deficit disorder, but his biggest projects have been the Portland State Aerospace Society, XCB, and Serialist. Twitter: @jamey_sharp. Projects: http://www.ohloh.net/accounts/jamey

  • Josh Triplett is a PhD student at Portland State University and a Free and Open Source Software hacker. He's involved in research on relativistic programming and advanced synchronization techniques for highly parallel systems. Josh builds and launches Linux-powered rockets with the Portland State Aerospace Society, and hacks on numerous other projects. Homepage with projects: http://joshtriplett.org/

Website
Monday
Feb 8, 2010
Portland Functional Programming Study Group
Roots Organic Brewing [Out of business. *Sigh*]

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: You can enter the event space through the glass doors on 7th that are close to the intersection with Clay, or through the front door and just look for signs to the event space. There will be pdxfunc signs on both.

Website
Monday
Mar 8, 2010
Portland Functional Programming Study Group
Roots Organic Brewing [Out of business. *Sigh*]
  1. Presentation: Jamey Sharp will give us a walk-through of the Haskell gzip deflate algorithm code that he and Josh Triplett developed.

  2. Group coding activity: We'll split up into groups that will each try to build an FP app from scratch in an hour, and then share the results with everyone. We'll make teams with people of different skill levels, so having FP coding skills will be useful but not required. My hope is this activity will give more folks a chance to explore and learn from others how to design and implement an FP app. Sample app ideas: blog, Twitter-clone, Sinatra-like web-framework, message queue client/server, filesystem directory browser, CSV-to-JSON converter, etc.

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: You can enter the event space through the glass doors on 7th that are close to the intersection with Clay, or through the front door and just look for signs to the event space. There will be pdxfunc signs on both.

Website
Monday
Apr 12, 2010
Portland Functional Programming Study Group
Portland State University Engineering Building

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: We're meeting in the PSU Engineering Building, 4th floor conference room. Any changes to plan will be listed on a sign taped to the main door. The building is at 1930 SW Fourth, Portland, Oregon 97201. It's on the right side of a large concrete courtyard. Here's a photo of the building: http://en.wikipedia.org/wiki/File:Portland_state_university_EB.jpg

Website
Monday
May 10, 2010
Portland Functional Programming Study Group
Roots Organic Brewing [Out of business. *Sigh*]

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: We're at the Roots Organic Brewing events room this month, at the corner of Clay and SE 7th. The room's entrance is the glass double doors on Clay, there will be a "pdxfunc" sign on them. There's also an interior entrance in the bar, ask the bartender how to get to the events room or look for a "pdxfunc" sign on a pair of solid double doors.

Website
Monday
Jul 12, 2010
Portland Functional Programming Study Group
Roots Organic Brewing [Out of business. *Sigh*]

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: We're at the Roots Organic Brewing events room this month, at the corner of Clay and SE 7th. The room's entrance is the glass double doors on Clay, there will be a "pdxfunc" sign on them. There's also an interior entrance in the bar, ask the bartender how to get to the events room or look for a "pdxfunc" sign on a pair of solid double doors.

Website
Monday
Aug 9, 2010
Portland Functional Programming Study Group
Lucky Labrador Brew Pub

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: This meeting will be in the Lucky Lab Brew Pub's events room. If you enter the pub through the front door on Hawthorne, the events room will be on your right on the hallway leading to the main room. There will be a 'pdxfunc' sign on the door.

Website
Monday
Sep 13, 2010
Portland Functional Programming Study Group
Lucky Labrador Brew Pub

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: This meeting will be in the Lucky Lab Brew Pub's events room. If you enter the pub through the front door on Hawthorne, the events room will be on your right on the hallway leading to the main room. There will be a 'pdxfunc' sign on the events room door.

Website
Monday
Oct 11, 2010
Portland Functional Programming Study Group
Lucky Labrador Brew Pub

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Dec 13, 2010
Portland Functional Programming Study Group
NedSpace Old Town

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jan 10, 2011
Portland Functional Programming Study Group
FlightStats

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Mar 14, 2011
Portland Functional Programming Study Group
FlightStats

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Apr 11, 2011
Portland Functional Programming Study Group
FlightStats

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

ABOUT THE VENUE: The meeting space is kindly provided by FlightStats. The building's doors and elevators will be locked in the evening, so look for a sheet of paper taped to the inside of the door with the phone number to call or text to get in. We'll also try to check if anyone's waiting at 6:50, 7:00 and 7:10pm if you don't have a phone.

Website
Monday
May 9, 2011
Portland Functional Programming Study Group
Lucky Labrador Brew Pub

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

ABOUT THE VENUE: The group will meet in the Events Room, the large glassed-in room by the main entrance on Hawthorne. There will a "pdxfunc" sign on the door. Feel free to show up early to eat and socialize, we have the room reserved from 6pm on.

Website
Monday
Jun 13, 2011
Portland Functional Programming Study Group
Portland State University Fourth Avenue Building, Room 155

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jul 11, 2011
Portland Functional Programming Study Group
Portland State University FAB, Room 86-09

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Aug 8, 2011
Portland Functional Programming Study Group
Collective Agency Downtown

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: This space is kindly provided to us by Collective Agency (http://collectiveagency.co/), which offers affordable meeting and work spaces, and Stumptown Syndicate (http://stumptownsyndicate.org/), a non-profit supporting technology education and professional development.

Website
Monday
Sep 12, 2011
Portland Functional Programming Study Group
Lucky Labrador Overlook Tap Room

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Oct 10, 2011
Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

This meeting's venue, food and drinks are kindly sponsored by Janrain, providers of hosted user management solutions for social login and sharing, single sign-on and social profile storage.

Website
Monday
Nov 14, 2011
Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Dec 12, 2011
Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Jan 9, 2012
Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Feb 13, 2012
Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Mar 12, 2012
Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Apr 9, 2012
Portland Functional Programming Study Group
Janrain Headquarters

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
May 14, 2012
Portland Functional Programming Study Group
Janrain Headquarters

PRESENTATIONS:

  • Gregory Benison on applying FP techniques for "real world" problems using C: I would like to present an example from my work in protein biochemistry where ideas from functional programming - namely lazy evaluation and immutable data - were important in approaching a "real world" problem. The program I want to discuss is implemented in C and I believe this to be a good example of how ideas from FP can be useful in almost any language.
  • ...and others

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Thursday
Jun 23, 2011
Portland Functional Programming Study Group birds-of-a-feather at Open Source Bridge
Eliot Center (First Unitarian Church)

Join us at the Open Source Bridge conference this week for a free birds-of-a-feather session to get together and share stories about our experiences with functional programming languages like Erlang, Haskell, Scala, OCaml, Clojure and others.

If you’d like to give a short talk (3-10 minutes), please prepare and mention it at the beginning of the meeting so we can add you to the agenda. We’ll spend the rest of the time on open discussions, which will be awesome.

The Portland Functional Programming Study Group and the Portland Scala Users Group meet regularly to discuss these sorts of topics. See http://pdxfunc.org/ and http://pdxscala.org/ for details.

IMPORTANT: If you don’t already have a ticket for the Open Source Bridge conference, you’ll need to either buy one or register for a free “Community Pass” that will let you into the Friday unconference, Hacker Lounge and the evening BoFs: http://osbridge.eventbrite.com/

Website
Monday
Jun 14, 2010
Portland Functional Programming Study Group: "Reinventing the Wheeler" and more
Roots Organic Brewing [Out of business. *Sigh*]

PRESENTATIONS

  1. "Reinventing Wheeler" by Matt Youell -- Wheeler is a lazy, imperative, declarative language with no functions and no objects. Some languages try to eliminate state. In Wheeler state is the primary abstraction. Wheeler is very early in development and is at a stage where feedback from the technical community would be greatly appreciated.

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: We're at the Roots Organic Brewing events room this month, at the corner of Clay and SE 7th. The room's entrance is the glass double doors on Clay, there will be a "pdxfunc" sign on them. There's also an interior entrance in the bar, ask the bartender how to get to the events room or look for a "pdxfunc" sign on a pair of solid double doors.

Website
Monday
Nov 9, 2009
Portland Functional Programming Study Group: Designing, visualizing and benchmarking data structures in Haskell
NedSpace Old Town

Title: Designing, visualizing and benchmarking data structures in Haskell

Abstract: Understanding how functional languages represent data structures is key to writing efficient programs in such languages. There are a number of new tools in the Haskell ecosystem for understanding what the compiler is doing: vacuum - for visualizing the heap, criterion - for statistically sound benchmarking, and powerful new type system features enabling new kinds of library design. This talk will introduce these tools, and we'll look at how they impact the way we develop new data structures in Haskell.

Bio: Don is an Australian open source hacker, and engineer at Galois, Inc, in Portland, where he works on assurance in critical systems. Don is co-author of the book, Real World Haskell (http://realworldhaskell.org), and the XMonad window manager. He enjoys cycling and hoppy beer.

GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

VENUE: Space for the meeting is kindly provided by NedSpace, a co-working space for startups, innovative technology companies, non-profits, artists and social entrepreneurs.

Website
Monday
Jun 8, 2009
Portland Functional Programming Study Group: F# with Jason Mauer
CubeSpace [ *sniff* out of business 12 June 2009]

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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

F#

Abstract: F# is a typed functional programming language for the .NET Framework, based on OCaml. F# combines functional programming with the runtime support, libraries, tools, and object model of .NET. Understand how F# tackles difficult development issues with ease, such as asynchronous programming and concurrency. Bask in the elegance of succinct, declarative code. Featuring the latest bits from Visual Studio 2010 Beta 1 -- don't miss it!

Speaker: Jason Mauer is a Senior Developer Evangelist with Microsoft covering the Pacific Northwest. He has been with Microsoft for 8 years, with a background in .NET application development, Web development, and game development with DirectX and XNA. Find him online at http://jasonmauer.com/ or on Twitter as @jasonmauer.

Website
Monday
Nov 8, 2010
Portland Functional Programming Study Group: Haskell DB & web app abstractions and more
NedSpace Old Town

TOPICS: * Jamey Sharp will talk about Haskell database and web application abstractions used in http://serialist.net * More...

ABOUT: Join programmers, researchers and enthusiasts to discuss functional programming. 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, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

Website
Monday
Sep 14, 2009
Portland Functional Programming Study Group: Slate and more
Lucky Labrador Brew Pub

Join programmers, researchers and enthusiasts to discuss functional programming.

VENUE The meeting will be in the events room. If you enter through the venue's Hawthorne entrance, this room will be on your right.

CONTENT * Brian Rice will talk about the functional aspects of his Slate programming language. * ...and other great talks and open discussions at the meeting.

Website
Tuesday
May 19, 2009
Portland Java User Group: The Feel of Scala
Oracle (Downtown Campus)

This month's topic: The Feel of Scala

Scala is a new language for the Java Platform that blends object-oriented and functional programming concepts. This talk will focus on the design choices of Scala, and what they mean for developer productivity. The talk will highlight what it means to program in a functional style, and show you how Scala facilitates a hybrid of functional and imperative programming styles. The talk will also explore how Scala compares to dynamic languages such as Ruby and Python. And you'll see examples of real, production Scala code that will illustrate what it feels like to program in Scala.

Speaker: Bill Venners

Bill Venners is president of Artima, Inc., publisher of Artima Developer (www.artima.com). He is author of the book, Inside the Java Virtual Machine, a programmer-oriented survey of the Java platform's architecture and internals. His popular columns in JavaWorld magazine covered Java internals, object-oriented design, and Jini. Active in the Jini Community since its inception, Bill led the Jini Community's ServiceUI project, whose ServiceUI API became the de facto standard way to associate user interfaces to Jini services. Bill is also the lead developer and designer of ScalaTest, an open source testing tool for Scala and Java developers, and coauthor with Martin Odersky and Lex Spoon of the book, Programming in Scala.


PJUG meetings start with some time to eat and socialize (pizza and beverages are provided), followed by the featured speaker, then Q&A, discussion, sometimes a drawing to give away swag. :)

Though we like knowing how many people to expect, you don't have to RSVP, on Upcoming or otherwise. Go ahead and just show up!

Many people also go for a drink and further discussion following the meeting, at a location determined ad hoc (more often than not, Jax on 2nd).

http://twitter.com/pjug http://pjug.org/ (join our mailing list, linked from the website!)

Website