Viewing 0 current events matching “haskell” by Location.

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

Viewing 77 past events matching “haskell” by Location.

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
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
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
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
Monday
Dec 12, 2016
Portland Functional Programming Study Group - Functional Discussions
Collective Agency Downtown Website
Monday
Feb 20, 2017
Portland Functional Programming Study Group - Haskell Lesson 1 and Data Parallelism
Collective Agency Downtown

This is the first month of our new format, based on discussion following the survey: The first half will be geared toward beginners, and the second half will be geared toward more advanced material.

For the next several months the beginner material will be a series of lessons in the Haskell programming language. We will be following Brent Yorgey's CIS 194 syllabus (http://www.seas.upenn.edu/~cis194/spring13/lectures.html). So bring a laptop, or just follow along. Between months you are encouraged to work on the assignments and we will review them. Lyle will be leading the lecture this month.

This month's advanced talk will be delivered by Leif, who will be following up his discussion of data parallelism in Spark (Scala) and Haskell.

Website
Monday
Apr 10, 2017
Portland Functional Programming Study Group - Haskell Lesson 3 and Category Theory
Collective Agency Downtown

This meeting continues our Haskell lesson series with Echo delivering Lesson 3 on Recursion Patterns, Polymorphism, and the Prelude from Brent Yorgey's CIS194 course (http://www.seas.upenn.edu/~cis194/spring13/lectures.html).

Lyle will give an introduction to category theory, a theory about mathematical structures and their relationships, which has applications in functional programming.

The meeting will be at Collective Agency in the Tiffany Center - the same place as the February meeting. The elevator is expected to be restored to operation by then. (UPDATE: Elevator service to the 8th floor has not yet been restored, so you will have to walk from the 4th floor.) Someone will wait in the lobby to let you in as the front doors are locked after 6. The meeting is on the 8th floor.

Website
Monday
May 15, 2017
PDXFunc - Portland Functional Programming Study Group
Collective Agency Downtown

We will continue our Haskell lesson series with Lyle delivering Lesson 4 on Higher-Order Programming and Type Inference from Brent Yorgey's CIS194 course.

Then Michael Beidler will present on full-stack "isomorphic" web apps with Haskell (REST APIs in servant and GHCJS front-ends with react-flux).

The 8th-floor elevator has been restored to operation, so there are no longer stairs to climb.

Website
Monday
Jun 19, 2017
Portland Functional Programming Study Group - Haskell Lesson 5 and the 1ML Language
Collective Agency Downtown

Join us for another fun-filled evening of learning and discussion!

Tonight, Lyle will present Lesson 5 from Brent Yorgey's CIS 194 lectures: http://www.seas.upenn.edu/~cis194/spring13/lectures/05-type-classes.html, as well as reviewing the homework from Lesson 4.

Then, Matt Rice will talk about the 1ML language, a variant of ML which unifies the main expression/type language with the language of the module system (signatures, structures and functors). He's also been creating his own language derived from it.

Website
Monday
Jul 17, 2017
Portland Functional Programming Study Group - Haskell Lesson 6 and Free Things
Collective Agency Downtown

This month, Leif will present Lesson 6 on Lazy Evaluation from Brent Yorgey's CIS 194 lectures.

Then, Rob Norris will talk about free things.

Meeting is on the 8th floor of the Tiffany Center. If you arrive before the meeting starts, there will be someone in the lobby to open the front door for you. If not, there will be a sign posted with a phone number for you to call, and someone will come down to let you in. Take the elevator on the right to the 8th floor, and exit to your right. The sign next to the space says Forge Portland. We meet in the large open area there. 

Website
Monday
Aug 14, 2017
Portland Functional Programming Study Group - Haskell Lesson 7 and A* in Elm
Collective Agency Downtown

This month, we'll be meeting in a new location! Collective Agency has moved to 511 SW 10th Ave. We'll be meeting in the main area.


First, we'll cover Lesson 7 on Folds and Monoids from Brent Yorgey's CIS 194 Haskell lectures.

Then, Jamon Holmgren will explain his implementation of the A pathfinding algorithm in Elm. A is used in games to calculate the least-cost path for a computer character to move from one spot to another. Elm is a language similar to Haskell (but simpler) that compiles down to JavaScript, used for apps that run in web browsers.

Website
Monday
Sep 11, 2017
Portland Functional Programming Study Group - Haskell Lesson 8 and Vintage BASIC
Collective Agency Downtown

Lyle will present Brent Yorgey's CIS 194 Lesson 8 on IO in Haskell.

Then Lyle will present Vintage BASIC, a BASIC interpreter he wrote in Haskell some years ago but has recently revised.

Website
Monday
Oct 9, 2017
Portland Functional Programming Study Group - Haskell Lesson 9 (Functors) and Minima (Elm)
Collective Agency Downtown

Echo will present Brent Yorgey's CIS 194 Lesson 9 on functors in Haskell.

Brian Ginsburg will give a short presentation on Minima (https://brianginsburg.com/minima/), a playground for experimenting with minimalist musical patterns, which he wrote in Elm.

We will have extra time in this meeting for hands-on learning. You are encouraged to bring a laptop or work together with someone else. You can practice working with functors, hack on Minima, or ask any other questions you might have.

Website
Monday
Nov 13, 2017
Portland Functional Programming Study Group - 10th Anniversary Party and New Format Kickoff
Collective Agency Downtown

Come celebrate the 10th anniversary of PDX Func! The first meeting was on 11/15/07. There'll be food and drink and cake! We'll also discuss the new format for meetings based on the survey results. We will also go over the Applicative Functor lesson from CIS 193, which will be our final lesson from that track.

Website
Monday
Mar 13, 2017
Portland Functional Programming Study Group - Haskell Lesson 2
Collective Agency Morrison

This month, Echo will be leading us through Haskell Lesson 2 (Week 2 at http://www.seas.upenn.edu/~cis194/spring13/lectures.html)! The category theory talk has been rescheduled for April.

Website
Tuesday
Mar 19, 2013
miniKanren Confo
Courtyard by Marriott City Center, Portland

The miniKanren Confo is a special 4 hour conference about logic programming (in particular miniKanren). Dan Friedman and Will Byrd (co-authors of the Reasoned Schemer) will provide a keynote. The list of sessions can be found on the Clojure/West site.

Registration ($50) is required and can be done either standalone or as part of registration with the Clojure/West conference (Mar 18-20th).

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
Friday
Dec 12, 2014
Galois tech talk: Making GHC work for you
Galois Inc

abstract: GHC is a state-of-the-art optimizing compiler that is constantly being improved. But despite all of the hard work by the developers, you occasionally find yourself in need of a feature that GHC does not (yet) support. Luckily for us, GHC does have multiple extension points built into the standard compilation pipeline, in addition to exposing its functionality as a library.

In this talk I’ll give an overview of GHC’s internal architecture and existing extension points. I’ll also walk through a recent extension I wrote to improve the debugging experience in embedded DSLs.

bio: Eric Seidel is a 3rd year PhD student at UC San Diego, where he works on the LiquidHaskell program-verification tool.

Website
Thursday
Jan 15, 2015
Galois Tech Talk: Dependently typed functional programming in Idris (part 1 of 3)
Galois Inc

abstract: Idris is a pure functional language with full dependent types. In this series of tech talks, Idris contributor David Christiansen will provide an introduction to programming in Idris as well as using its development tools. Topics to be covered include the basics of dependent types, embedding DSLs in Idris, Idris’s notion of type providers, a general outline of the implementation strategy, the C FFI, and the effects library. Each talk has an associated set of exercises as well as suggested projects for further learning. Participants are expected to be familiar with functional programming in either Haskell or an ML.

bio: David Raymond Christiansen is a Ph.D. student at the IT University of Copenhagen. For the last few months, he has been an intern at Galois, working on verifiable elections and better user interfaces for DSLs. His interests include functional programming languages, domain-specific languages, and environments that make them useful. David has contributed features such as type providers and error reflection to the Idris language as well as significant parts of the Emacs-based IDE. Additionally, he is a co-host of The Type Theory Podcast.

Website
Tuesday
Apr 7, 2015
Galois tech talk: From Haskell to Hardware via CCCs
Galois Inc

abstract: For the last several years, speed improvements in computing come mainly from increasing parallelism. Imperative programming, however, makes parallelization very difficult due to the many possible dependencies implied by effects. For decades, pure functional programming has held the promise of parallel execution while retaining the very simple semantics that enables practical, rigorous reasoning. This talk describes a prototype compiler from Haskell (not a library) to low-level hardware descriptions for massively parallel execution on reprogrammable logic devices. The compiler works by monomorphizing, miscellaneous other transformations, and conversion to the vocabulary of cartesian closed categories (CCCs), as captured in a small collection of Haskell type classes. One instance of those classes provides an interpretation as parallel circuits. I will show many examples of simple Haskell programs and corresponding compiler-generated circuits.

bio: Conal Elliott has been working (and playing) in functional programming for more than 30 years. He especially enjoys applying semantic elegance and rigor to library design and optimized implementation. He invented the paradigm now known as “functional reactive programming” in the early 1990s, and then pioneered compilation techniques for high-performance, high-level embedded domain-specific languages, with applications including 2D and 3D computer graphics. The latter work included the first compilation of Haskell programs to GPU code, while maintaining precise and simple semantics and powerful composability, as well a high degree of optimization. Conal earned a BA in math with honors from the College of Creative Studies at UC Santa Barbara in 1982 and a PhD in Computer Science from Carnegie Mellon University in 1990. His latest position was at Tabula Inc, where he worked on chip specification and compiling Haskell to hardware for massively parallel execution until their closure in early 2015. Before Tabula, his positions included Architect at Sun Microsystems and Researcher in the Microsoft Research graphics group. He has also coached couples and led conscious relationship workshops together with his partner Holly Croydon, with whom he now lives on 20 acres in the woods in the California Gold Country. For publications, CV, professional blog, etc, see http://conal.net.

Website
Friday
Dec 14, 2018
Tech Talk: Teaching Haskell in the Real World
Galois Inc.

Abstract:

Teaching programming is a hard job. Teaching Haskell is a way harder given its inherent complexity and expectations students have. Nevertheless, there are many approaches to do that. In this talk, I would like to outline the practices that I use and those that I don’t find fruitful. There are quite a few books that can be used for teaching, and I will try to categorize them in terms of their ability to educate a professional Haskell developer. Haskell is a big language, so what should be taught is another crucial question. Should it be a course on functional programming in general or Haskell specifics are fine to teach? For example, there is no clear answer on whether you should attempt teaching something like lenses or stream I/O given limited time. How to teach students about monads? Well, everyone knows the right answer, I will describe my approach. I will also talk about ways to motivate students and to make them learn Haskell by themselves.

Speaker:

Vitaly Bragilevsky, Senior Lecturer at Southern Federal University

Bio:

Vitaly Bragilevsky serves as both the Haskell 2020 Language Committee and the GHC Steering Committee member. He works as a Senior Lecturer at the Southern Federal University in Rostov-on-Don, Russia where he teaches undergraduate students functional programming and theory of computations. He is the author of ‘Haskell in Depth’ (Manning Publications, available via Manning’s early access program).

Recording:

The presentation will be live streamed on our YouTube channel.

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
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
Tuesday
Oct 6, 2009
Galois Tech Talk: Roll Your Own Test Bed for Embedded Real-Time Protocols: A Haskell Experience
Galois, Inc

The next talk in the Galois Tech Seminar series:

  • Date: Tuesday, October 6th, 2009
  • Title: Roll Your Own Test Bed for Embedded Real-Time Protocols: A Haskell Experience
  • Speaker: Lee Pike
  • Time: 10:30am - 11:30am
  • Location: Galois, Inc. 421 SW 6th Ave. Suite 300; Portland, OR 97204

For details (including an abstract and speaker bio), please see our blog post: http://www.galois.com/blog/2009/09/29/pike-haskell0/

Abstract: We present by example a new application domain for functional languages: emulators for embedded real-time protocols. As a case-study, we implement a simple emulator for the Biphase Mark Protocol, a physical-layer network protocol in Haskell. The surprising result is that a pure functional language with no built-in notion of time is extremely well-suited for constructing such emulators. Furthermore, we use Haskell’s property-checker QuickCheck to automatically generate real-time parameters for simulation. We also describe a novel use of QuickCheck as a probability calculator for reliability analysis.

Bio: Lee Pike is a member of the technical staff at Galois. Previously, he was a research scientist with the NASA Langley Formal Methods Group, primarily involved in the SPIDER project. His research interests include applying formal methods to safety-critical and security-critical applications, with a focus on industrial-scale endeavors.

An RSVP is not required; but feel free to drop a line to [email protected] if you've any questions or comments.

Levent Erkok

Website
Tuesday
Oct 20, 2009
Galois Talk: Writing Linux Kernel Modules with Haskell
Galois, Inc

The next talk in the Galois Tech Seminar series:

  • Date: Tuesday, October 20th, 2009
  • Title: Writing Linux Kernel Modules with Haskell
  • Speaker: Thomas DuBuisson
  • Time: 10:30am - 11:30am
  • Location: Galois, Inc. 421 SW 6th Ave. Suite 300; Portland, OR 97204

For details (including an abstract and speaker bio), please see our blog post: http://www.galois.com/blog/2009/10/13/haskellkernelmodules/

An RSVP is not required; but feel free to drop a line to [email protected] if you've any questions or comments.

Levent Erkok

Website
Tuesday
Nov 3, 2009
Galois Talk: Testing First-Order-Logic Axioms in AutoCert
Galois, Inc

The next talk in the Galois Tech Seminar series:

  • Date: Tuesday, November 3rd, 2009
  • Title: Testing First-Order-Logic Axioms in AutoCert
  • Speaker: Ki Yung Ahn
  • Time: 10:30am - 11:30am
  • Location: Galois, Inc. 421 SW 6th Ave. Suite 300; Portland, OR 97204

For details (including an abstract and speaker bio), please see our blog post: http://www.galois.com/blog/2009/10/28/ahn-autocert/

An RSVP is not required; but feel free to drop a line to [email protected] if you've any questions or comments.

Levent Erkok

Website
Saturday
Nov 14, 2009
Darcs Hacking Sprint
through Galois, Inc

Who : Anybody who wants to hack on Darcs (or Camp, Focal, SO6, etc) Beginners especially welcome!

Why : Darcs aims to have bi-annual hacking sprints so that we can get together on a regular basis, hold design discussions, hack up a storm and have a lot fun.

What : We plan to put some finishing touches on Darcs-2.4. Darcs 2.4 is a pretty exciting release because we expect it to offer nice performance enhancements from Petr's Google

Summer of Code Project, and also a nice new 'hunk splitting' feature.

We also intend to set aside at least one Darcs hacker for mentoring beginners, so if you're new to Haskell or to Darcs hacking, here's a good chance to plunge in and start working on a real world project.

How: Add yourself to http://wiki.darcs.net/Sprints/2009-11

Website
Tuesday
Dec 15, 2009
Galois Tech Talk: Beautiful Differentiation
Galois, Inc

The December 15th Galois Tech Talk will be delivered by John Launchbury. He will present Conal Elliott’s 2009 ICFP paper entitled Beautiful Differentiation for those of us who were not able to attend this wonderful talk in-person.

Website
Friday
Jan 29, 2010
Galois Tech Talk: A Scalable I/O Manager for GHC
Galois, Inc

A Scalable I/O Manager for GHC

Presented by Johan Tibell.

Abstract: The Glasgow Haskell Compiler supports extraordinarily cheap threads. These are implemented using a two-level model, with threads scheduled across a set of OS-level threads. Since the lightweight threads can’t afford to block when performing I/O operations, when a Haskell program starts, it runs an I/O manager thread whose job is to notify other threads when they can safely perform I/O.

The I/O manager manages its file descriptors using the select system call. While select performs well for a small number of file descriptors, it doesn’t scale to a large number of concurrent clients, making GHC less attractive for use in large-scale server development.

This talk will describe a new, more scalable I/O manager that’s currently under development and that hopefully will replace the current I/O manager in a future release of GHC.

Details: Date: January 29th, 2010, Friday Time: 1:30pm Location: Galois Inc., 421 SW 6th Ave. Suite 300 (3rd floor of the Commonwealth building)

Bio: Johan Tibell is a Software Engineer at Google Inc. He received a M.S. in Software Engineering from the Chalmers University of Technology, Sweden, in 2007.

Website
Tuesday
May 18, 2010
Galois Tech Talk: Developing Good Habits for Bare-Metal Programming
Galois, Inc

presenter: Mark Jones

abstract: Developers of systems software must often deal with low-level and performance-critical details that are hard to address in high-level programming languages. As a result, much of the systems software that is produced today is written in languages like C and assembly code, without the benefit of more expressive type systems or other features from modern functional programming languages that could help to increase programmer productivity or software quality. In this talk, we present an update on the status of Habit, a dialect of Haskell that we are designing, as part of the HASP project at PSU, to meet the needs of high assurance systems programming. Among other features, Habit provides: mechanisms for fine control over representation of bit-level and memory-based data structures; strong support for both functional and imperative programming; and a flexible type system that allows precise characterization of size and bound information via type level naturals, as well as termination properties resulting from the use of unpointed types.

Website
Tuesday
Feb 15, 2011
Galois Tech Talk: Faster Persistent Data Structures Through Hashing
Galois, Inc

Presented by Johan Tibell.

The most commonly used map (dictionary) data type in Haskell is implemented using a size balanced tree. While size balanced trees provide good asymptotic performance, their real world performance is not stellar, especially when used with keys which are expensive to compare, such as strings.

In this talk we will look at two different map implementations that use hashing to achieve better real world performance. The implementations have different performance characteristics: one provides very fast look-ups while the other trades better insert performance for somewhat slower look-ups. I will describe the design of these data structures and show some early benchmark results.

Website
Tuesday
Mar 15, 2011
Galois Tech Talk: Haskell And The Social Web
Galois, Inc

Presented by Philip Weaver.

Janrain offers user management services that include single sign-on, social login, and profile storage. We have recently begun using Haskell extensively to implement our products, and would like to share what the experience has been like.

In this talk we will give a technical demonstration of Capture, whose backend is written in Haskell, discuss some of the implementation details of Capture, and look at some of the joys and pitfalls that we experienced.

Website
Tuesday
May 10, 2011
Galois Tech Talk: Empirical Sampling With Haskell
Galois, Inc

Presented by Chad Scherrer.

Sampling from a large discrete distribution is a common problem in statistics. In this talk, we'll consider a real-world situation where the properties of the distribution cause common approaches to break down, and we'll arrive at a Haskell-based solution that fixes the problem.

Website
Tuesday
Aug 16, 2011
Tech Talk: Back-to-back talks on Haskell and Embedded Systems
Galois, Inc

Presented by Sebastian Niller and Nis N. Wegmann

1

title: Translation of Functionally Embedded Domain-specific Languages With Static Type Preservation by using Witnesses

abstract: Static type preservation automatically guarantees type-correctness of an embedded domain-specific language (eDSL) by tying its type system to that of the host-language. Not only does this obviate the need for a custom type checker, it also preserves type-correctness during code transformations and optimizations, and simplifies and increases the efficiency of interpreters. When implementing a translator from a source DSL with type preservation to a target DSL, the commonly chosen approach requires the incorporation of extensions in the source DSL specific to the target DSL, which, in cases where multiple back-ends are required, obfuscates the source DSL and decreases the overall modularity. We show that by using witnesses, a technique which facilitates the construction of type-level proofs, we can effectively cope with this issue and implement translators without extending the source DSL.

We have applied our approach on Copilot, a Haskell-embedded domain specific language for runtime monitoring of hard real-time distributed systems, and used it for implementing two back-ends targeting the Haskell-embedded languages Atom and SBV. Our approach restrains to the Haskell 2010 Standard except for existentially and universally quantified types.

2

title: From High-Level Languages to Monitoring Fault-Tolerant Hardware: Case-Studies of Runtime Verification Using Copilot

abstract: Failures of hard real-time systems can be caused by systematic faults in software and hardware, as well as by random hardware faults, and faults due to wear out of hardware components. Even if monitoring software is proven to comply to its specification, there is no guarantee that failing underlying hardware does not affect the monitors themselves. An application of distributed Copilot monitors to a redundant airspeed measurement system is presented. We show the use of monitors enables the system to withstand benign and Byzantine hardware and software faults.

The second part of the talk presents current work using Copilot to monitor the MAVLink protocol in flight of a sub-scale model of an Edge 540T aircraft.

Website
Tuesday
Jan 10, 2012
Galois Tech Talk (1 of 3 next week!): Formalizing Haskell 98 in the K Semantic Framework
Galois, Inc

Presented by David Lazar

Formal semantics is notoriously hard. The K semantic framework (http://k-framework.org/) is a system that makes the task of formally defining programming languages easy and practical. The primary goals of the K framework are modularity, expressivity, and executability. Adding a new language feature to a K definition does not require you to revisit and modify existing semantic rules. The K framework is able to concisely capture the semantics of non-determinism and concurrency. Each K definition automatically yields an interpreter for the language so that the definition can be tested for correctness. These features made it possible to develop a complete formal semantics of the C language in K. The first half of the talk will be an overview of the K semantic framework. We'll discuss the merits of the framework using the K definition of a complex toy language as a guiding example. The second half of the talk will focus on a work-in-progress formalization of Haskell 98 in K. We'll look at the challenges of formalizing Haskell and the applications of this work.

Website
Thursday
Aug 30, 2012
Galois Tech Talk: Formal Verification of Monad Transformers
Galois, Inc

Presented by Brian Huffman.

We present techniques for reasoning about constructor classes that (like the monad class) fix polymorphic operations and assert polymorphic axioms. We do not require a logic with first-class type constructors, first-class polymorphism, or type quantification; instead, we rely on a domain-theoretic model of the type system in a universal domain to provide these features. These ideas are implemented in the Tycon library for the Isabelle theorem prover, which builds on the HOLCF library of domain theory. The Tycon library provides various axiomatic type constructor classes, including functors and monads. It also provides automation for instantiating those classes, and for defining further subclasses. We use the Tycon library to formalize three Haskell monad transformers: the error transformer, the writer transformer, and the resumption transformer. The error and writer transformers do not universally preserve the monad laws; however, we establish datatype invariants for each, showing that they are valid monads when viewed as abstract datatypes.

Website
Tuesday
Jun 25, 2013
Galois Tech Talk: The Constrained-Monad Problem
Galois, Inc

Presented by Neil Sculthorpe.

In Haskell, there are many data types that would form monads were it not for the presence of type-class constraints on the operations on that data type. This is a frustrating problem in practice, because there is a considerable amount of support and infrastructure for monads that these data types cannot use. This talk will demonstrate that a monadic computation can be restructured into a normal form such that the standard monad class can be used. The technique is not specific to monads --- it can also be applied to other structures, such as applicative functors. One significant use case for this technique is Domain Specific Languages, where it is often desirable to compile a deep embedding of a computation to some other language, which requires restricting the types that can appear in that computation.

Website
Monday
Jul 29, 2013
Galois tech talk: Type-directed compilation in the wild: Haskell and Core
Galois, Inc

Academic papers often describe typed calculi, but it is rare to find one in a production compiler. Indeed, I think the Glasgow Haskell Compiler (GHC) may be the only production compiler in the world that really has a remorselessly statically-typed intermediate language, informally called "Core", or (when writing academic papers) the more respectable-sounding "System FC".

As real compilers go, GHC's Core language is tiny: it is a slight extension of System F, with letrec, data types, and case expressions. Yet all of Haskell (now a bit of a monster) gets translated into it. In the last few years we have added one new feature to Core, namely typed (but erasable) coercions that witness type equalities, which turn Core into a particular kind of proof-carrying code. This single addition has opened the door to a range of source-language extensions, such as GADTs and type families.

In this talk I'll describe Core, and how it has affected GHC's development over the last two decades, concentrating particularly on recent developments, coercions, evidence, and type families. To test your mettle I hope to end up with the problem we are currently wrestling with: proving consistency of a non-terminating rewrite system with non-left-linear rules.

Website
Friday
Jun 13, 2014
Galois tech talk: Haskell Bytes
Galois, Inc

speaker: Joachim Breitner

abstract: We will take you on a guided tour through the memory of a running Haskell program and get to peek at the raw bytes of Haskell values. We’ll see how uniformity allows for polymorphic functions and data structures, where the garbage collector finds the information it needs and learn to predict how large certain values tend to become. With the help of a visualization tool (ghc-vis) we will also see laziness and sharing at work, and reveal the mystery of how Haskell fits infinite data structures into a finite amount of memory.

bio: Joachim Breitner is a PhD student at the Karlsruhe Institute of Technology, Germany, where he works on the semantics of lazy functional programming language and on interactive theorem provers. He maintains the Haskell packages for Debian and Ubuntu and contributes to GHC. When he is AFK, he enjoys board games, swing dancing, softball and paragliding.

Website
Monday
Jun 30, 2014
Haskell Office Hours
Galois, Inc

(from the Meetup page, please RSVP there!)

Our inaugural meeting will be a full-fledged office hours session! Bring your projects, or just your excitement for learning.

We will also be taking feedback on the format of the meetup, the scheduling, and anything else that will help make this a valuable resource for you. If you are not able to attend, let us know if there's anything we can do to help make it work in the future.

Website
Tuesday
Jul 8, 2014
Galois tech talk: Sunroof and a Blank Canvas: A tail of two DSLs
Galois, Inc

abstract: Sunroof is an embedded Haskell Domain Specific Language (DSL) that compiles to JavaScript. Blank Canvas is an embedded Haskell DSL that provides direct access to the HTML5 JavaScript Canvas. Both DSLs superficially provide the same capabilities, but make different trade-offs in the DSL design space. Sunroof uses monadic reification to enable bindings in the DSL to be translated into bindings in JavaScript, while blank canvas has every binding make a round trip from Haskell, to JavaScript, back to Haskell. In this talk, we will present the specifics of both DSLs, using examples, then use both DSLs to outline the difference choices available when designing and implementing embedded DSLs in Haskell.

bio: Andrew (Andy) Gill was born and educated in Scotland, and has spent his professional career in the United States, working both in industry, and academia. Andy received his Ph.D. from the University of Glasgow in 1996, then spent three years in industry as a compiler developer, and a year in academia as a principal project scientist. He co-founded Galois in 2000, a technology transfer company that used language technologies to create trustworthiness in critical systems. In 2008, he joined the University of Kansas, and in 2014 he was a recipient of the NSF CAREER Award.

Andy believes that functional languages like Haskell are a great medium for expressing algorithms and solving problems. Since returning to academia, he has targeted the application areas of telemetry and signal processing, specializing in generating high performance circuits from specifications. His research interests include optimization, language design, debugging, and dependability. The long-term goal of his research is to offer engineers and practitioners the opportunity to write clear and high-level executable specifications that can realistically be compiled into efficient implementations.

Website
Thursday
Nov 12, 2015
Haskell Office Hours
Galois, Inc

(from the Meetup description):

Welcome to Portland Haskell Office Hours! Bring your projects, or just your excitement for learning.

We will still be taking feedback on the format of the meetup, the scheduling, and anything else that will help make this a valuable resource for you. If you are not able to attend, let us know if there's anything we can do to help make it work in the future.

--

About Haskell Office Hours:

Show up with a project you'd like to share or a problem that you're stuck on, and we'll learn together in small, supportive groups! An "Office Hours" meetup is an opportunity for people of all skill levels to come together, learn, and have fun. Our goal is to focus on inclusion and active participation through teaching and mentorship.

The meetup is hosted at Galois, which uses Haskell extensively in industry, and is well-attended by Galwegians who are eager to share their excitement for Haskell and functional programming. This group is very new, so you still have an opportunity to shape how we do things. If the schedule doesn't work for you, or if we can do anything to help you feel more safe and welcome, let us know!

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
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
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
Friday
Feb 19, 2016
Snowdrift.coop meetup
Lucky Labrador Beer Hall

Snowdrift.coop casual chat, hang-out, open to all supporters, volunteers, curious folks, and guests. At this meetup, we'll be visit with new Community Director William "Salt" Hale who is coming down from Seattle.

Snowdrift.coop is a non-profit community platform building a new sustainable patronage system for public goods (particularly free/libre/open works). We welcome volunteers in all areas including non-technical general design, organizing, and co-op structure issues. On the technical side, the site uses the Yesod web framework written in Haskell alongside basic HTML/CSS/JavaScript.

We have a strong Portland foundation with one of the co-founders, the lead developer, and several active volunteers and supporters in the area.

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
Friday
Aug 28, 2015
Snowdrift.coop casual meetup / chat
Lucky Labrador Brew Pub

Snowdrift.coop is a volunteer-built non-profit community project focused on a new sustainable matching system to coordinate the global community in better funding shareable freely-licensed works. The Snowdrift.coop platform uses the Yesod web framework written in Haskell. Other technologies and relevant work includes basic HTML/CSS/JavaScript and general design, organizing, and other non-technical tasks.

This is the second local Portland meetup. While the community includes people on many continents across the globe, we have a strong Portland foundation with one of the co-founders, the lead developer, and several active volunteers and supporters in the area.

At this meetup, we'll mostly discuss the project overall status, strategy, any other casual chat, planning, and organizing. We'll also focus on just folks getting to know each other as local Portlanders involved in the project. Complete newcomers or just folks curious about the idea are totally welcome, and no particular experience or skills are needed to get involved.

Website
Saturday
Dec 5, 2015
Snowdrift.coop meetup / chat / hack session
Lucky Labrador Brew Pub

Snowdrift.coop is a volunteer-built non-profit community project focused on a new sustainable matching system to coordinate the global community in better funding shareable freely-licensed works. The Snowdrift.coop platform uses the Yesod web framework written in Haskell. Other technologies and relevant work includes basic HTML/CSS/JavaScript and general design, organizing, and other non-technical tasks like co-op structure issues.

While the community includes people on many continents across the globe, we have a strong Portland foundation with one of the co-founders, the lead developer, and several active volunteers and supporters in the area.

At this meetup, we'll mix casual chat with focusing on some refactoring on the Haskell side and hacking on HTML/CSS stuff for the new design.

Website
Thursday
Jan 21, 2016
Snowdrift.coop meetup / SCALE-send-off
Lucky Labrador Brew Pub

Snowdrift.coop is a non-profit community platform building a new sustainable patronage system for public goods (particularly free/libre/open works). The site uses the Yesod web framework written in Haskell alongside basic HTML/CSS/JavaScript. We welcome volunteers in all areas including non-technical general design, organizing, and other tasks like co-op structure issues.

We have a strong Portland foundation with one of the co-founders, the lead developer, and several active volunteers and supporters in the area.

At this meetup, we'll be meeting long-time volunteer Jason Harrer (aka JazzyEagle) who is in town for a rare business visit. We'll also be celebrating and wishing well to Aaron and Bryan who are heading down to the Southern California Linux Expo to promote Snowdrift.coop this weekend.

Website
Monday
May 8, 2017
Beaverton Haskell Meetup - Write You a Scheme 2.0 - Session 1
Oregon Technology Buisiness Center (OTBC)

Hello!

Thanks to everyone who attended the kickoff meeting for this group.  It was a really good turn out and looks like there are a lot of folks excited about learning some Haskell.  We have decided at this point to meet on a bi-weekly basis Mondays at 6:30pm.  We also have a new venue which has been secured at the OTBC offices thanks to Phil for the referral on that one.  We have also decided that we will be going through the online tutorial Write You a Scheme 2.0 as our first project.  Each person will choose resources on their own to learn Haskell and we will come together as a group in each meeting to talk about our progress on building a scheme interpreter and our understanding of the code presented.  Most likely we will also do some Haskell exercises as a group to help solidify new concepts.

To prepare for the next meetup go through the introduction and if you have time, the next section on parsers as well.  We'll try to cover as much ground as we have time available.

We also have a Slack channel that you can join by clicking the link that was sent out on the mailing list.  If you need an invite link let me know and I'll get you connected.

Website
Monday
Jul 31, 2017
Beaverton Haskell Meetup - Haskell Projects
Oregon Technology Buisiness Center (OTBC)

It's been a while since I've updated the description for this meetup's events.  So, the group originally started to learn Haskell from scratch.  The group agreed that we would each choose our own learning materials to work from during the week and then come together during the meeting to discuss and work on programming exercises together.  Since then we have started working on larger projects in Haskell and are starting to investigate more advanced features of the language.  If you have something that you've been working on that you would like to share or you would like to help someone else with their own project then please join us!  We're always looking to meet more folks who are interested in the virtues of functional programming.

Website
Wednesday
Sep 20, 2017
Beaverton Haskell Meetup
Oregon Technology Buisiness Center (OTBC)

Bring whatever Haskell project you happen to be working on and we'll spend a couple hours helping each other with them.

Website
Wednesday
Sep 27, 2017
Haskell User Group
Oregon Technology Buisiness Center (OTBC)

All experience levels are welcome, but the group's focus is on intermediate topics. The meeting this evening will be unstructured: we will discuss the direction and goals of the group.

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
Wednesday
Aug 11, 2010
Portland State University Haskell Interest Group [PHIG]
Portland State University FAB, Room 86-09

The PSU Haskell Interest Group is intended to provide a meeting place for PSU students and others who are users and developers of the Haskell programming language. Nothing too structured; brief talks and a chance to meet and discuss.

Website
Friday
Jul 22, 2011
HacPDX II
through Portland State University Fourth Avenue Building (FAB)

HacPDX-II is an opportunity to join Portland Haskell hackers in building and improving Hackage libraries and tools. The project you hack on can be anything and need-not be pre-existing or general community tools.

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