Viewing 0 current events matching “functional programming” by Date.

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

Viewing 170 past events matching “functional programming” by Date.

Sort By: Date Event Name, Location , Default
Tuesday
Aug 19, 2008
Galois Tech Talk: Adventures in Foreign Function Interfaces
Galois, Inc

Title: Adventures in Foreign Function Interfaces

Speaker: Joel Stanley

        Galois, Inc.

Date: Tuesday, August 19th, 10.30am

Location: Galois, Inc.

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

Abstract:

In-process integration and data exchange between multiple language
runtimes is a classic software engineering challenge.  This talk
describes our experiences in building an open-source tool for
generating an "FFI bridge" between Poly/ML and OCaml, via the common
C FFI provided by both language's runtimes.

The first intended use of this tool is to programmatically generate
a bridge between Isabelle (on the Poly/ML side) and Intel's Decision
Procedure Toolkit API (on the OCaml side).

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 <d...@galois.com> is appreciated, but not required.
If you're interested in giving a talk, we're always looking for new
speakers. 
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.

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 <[email protected]> is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers.
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.
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
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
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
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
Thursday
Oct 30, 2008
Galois Tech Talk: Slava Pestov on the Factor programming language
Galois, Inc

Factor is a programming language which has been in development for a little over 5 years. Factor is influenced by Forth, Lisp, Smalltalk. Factor takes the best ideas from Forth — simplicity, short, succint, code, emphasis on interactive testing, and meta-programming. Factor also brings modern high-level language features such as garbage collection, object orientation and functional programming familiar to users of languages such as Lisp, Smalltalk and Python. Finally, recognizing that no programming language is an island, Factor is portable, ships with a full-featured standard library, deploys stand-alone binaries, and interoperates with C and Objective-C.

In this talk, I will give the rationale for Factor’s creation, present an overview of the language, and show how Factor can be used to solve real-world problems with a minimum of fuss. At the same time, I will emphasize Factor’s extensible syntax, meta-programming and reflection capabilities, and show that these features, which are unheard of in the world of mainstream programming languages, make programs easier to write, more robust, and fun.

Biography:

Slava was born in the former USSR and emigrated to New Zealand at the age of 7. He moved to Ottawa, Canada when he was 18 to study for a Bachelors and Masters degree in Mathematics.  He now resides in Minneapolis, Minnesota. An early adopter of Java, Slava wrote the popular jEdit text editor, then went on to design and implement the Factor programming language. At his day job he hacks on web apps, optimizing compilers, garbage collectors, and everything in between

. Galois 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 d...@galois.com is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers.

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Tuesday
Feb 2, 2010
Galois Tech Talk: "An Introduction to the Maude Formal Tool Environment"
Galois, Inc

Hello,

The next Galois Tech Talk will be "An Introduction to the Maude Formal Tool Environment", presented by Joe Hendrix on Tuesday, February 2nd, at 10:30am.

For more details, please visit: http://www.galois.com/blog/2010/01/29/tech-talk-an-introduction-to-the-maude-formal-tool-environment/

Hope to see you there! -Iavor

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
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
Monday
May 24, 2010
Galois Tech Talk: The L4.verified Project
Galois, Inc

The L4.verified Project Presented by Dr. Gerwin Klein.

Last year, the NICTA L4.verifed project produced a formal machine-checked Isabelle/HOL proof that the C code of the seL4 OS microkernel correctly implements its abstract implementation. This talk will give an overview of the proof together with its main implications and assumptions, and will show in which kinds of systems this formally verified kernel can be used for gaining assurance on overall system security.

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
Tuesday
Jun 15, 2010
Galois Tech Talk: Introducing Well-Founded Recursion
Galois, Inc

Introducing Well-Founded Recursion Eric Mertens

Implementing recursive functions can be tricky when you want to be certain that they eventually terminate. This talk introduces the concept of well-founded recursion as a tool for implementing recursive functions. It implements these concepts in the Agda programming language and demonstrates the technique by implementing a simple version of Quicksort.

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
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
Tuesday
Aug 24, 2010
Galois Tech talk: abcBridge: Functional interfaces for AIGs and SAT solving
Galois, Inc

abcBridge: Functional interfaces for AIGs and SAT solving

Edward Z. Yang

SAT solvers are perhaps the most under-utilized high-tech tools that the modern software engineer has at their fingertips. An industrial strength SAT solver can solve most human generated NP-complete problems in time for lunch, and there are many, many practical problem domains which involve NP-complete problems. However, a major roadblock to using a SAT solver in your every day routine is translating your problem into SAT, and then running it on a highly optimized SAT solver, which is probably implemented in C or C++ and not your usual favorite programming language.

This talk is about the use, design and implementation of abcBridge, a set of Haskell bindings for ABC, a system for sequential synthesis and verification produced by the Berkeley Logic Synthesis and Verification Group. ABC looks at SAT solving from the following perspective: given two circuits of logic gates (ANDs and NOTs), are they equivalent? ABC is imperative C code: abcBridge provides a pure and type-safe interface for building and manipulating and-inverter graphs. We hope to release abcBridge soon as open source.

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
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
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
Thursday
Jan 20, 2011
PDXScala: Octobot distributed queue worker, bridging JRuby and Scala, etc
Simple (old office)

PDXScala is the Portland, Oregon based Scala users group.

The meeting will be at BankSimple, please use this door -- there will be a "PDXscala" sign on it.

PRESENTATIONS * Scott Andreas showing off the Scala port of his Octobot project, which was recently deployed successfully to handle a heavy job processing load at UrbanAirship. * Stephen Judkins will also show off some work he's done to integrate JRuby and Scala. * If you have any topics you'd like to discuss or code you'd like to show off, please bring it along!

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
Thursday
May 19, 2011
PDXScala
Simple (old office)

Kender Elford will talk about doing OpenGL programming with Scala, and Leif Warner will do a short talk on using the Spray library, an asynchronous microframework for building full RESTful servlets on top of Akka actors. The meeting will take place at 7PM at the BankSimple offices (aka, the Urban Airship building), which is located at 334 NW 11th (at the intersection of 11th and Flanders). If you have any trouble finding it, feel free to call me at 971-322-9408. If possible, I'll try to make sure we have some pizza there (anyone want to sponsor this month?). Also, I believe we have a free ticket for OpenSource Bridge to give away.

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
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
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
Thursday
Jul 21, 2011
PDXScala
Simple (old office)

This will be a pretty casual meeting, but still worthwhile. Bryan Armstrong said he could speak a bit on the new parallel collections support in Scala 2.9. Thomas Lockney may quickly show off a basic Akka demo, but that's looking iffy at this point. If you have anything else you'd like to come talk about, feel free to do so!

If you haven't been to the BankSimple office before, we have a space in the UrbanAirship building.

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

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
Wednesday
Dec 7, 2011
PDXScala Meeting
Janrain Headquarters

Come join other Scala enthusiasts to talk about all-things Scala related. Whether you're a newcomer or are writing books on the subject, we welcome you. If you're interested in giving a talk or have a talk you'd like someone to give (we'll do our best to find someone qualified), let us know.

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
Wednesday
Feb 1, 2012
PDXScala Meeting
Janrain Headquarters

Come join other Scala enthusiasts to talk about all-things Scala related. Whether you're a newcomer or are writing books on the subject, we welcome you. If you're interested in giving a talk or have a talk you'd like someone to give (we'll do our best to find someone qualified), let us know.

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
Wednesday
Mar 7, 2012
PDXScala Meeting
Janrain Headquarters

Come join other Scala enthusiasts to talk about all-things Scala related. Whether you're a newcomer or are writing books on the subject, we welcome you. If you're interested in giving a talk or have a talk you'd like someone to give (we'll do our best to find someone qualified), let us know.

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
Wednesday
Apr 4, 2012
PDXScala Meeting
Janrain Headquarters

Come join other Scala enthusiasts to talk about all-things Scala related. Whether you're a newcomer or are writing books on the subject, we welcome you. If you're interested in giving a talk or have a talk you'd like someone to give (we'll do our best to find someone qualified), let us know.

Perhaps Thomas and Leif could talk about the things seen at NEScala last month. Check the mailing list for updates/discussion: http://groups.google.com/group/pdxscala

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
Wednesday
May 2, 2012
PDXScala Meeting
Janrain Headquarters

Come join other Scala enthusiasts to talk about all-things Scala related. Whether you're a newcomer or are writing books on the subject, we welcome you. If you're interested in giving a talk or have a talk you'd like someone to give (we'll do our best to find someone qualified), let us know.

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
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
Wednesday
Jun 20, 2012
clojerks: Data-driven web applications in ClojureScript
Simple

Kevin Lynagh will talk to us about data-driven web applications with ClojureScript:

A web page or application is, at its core, just a visual representation of data that people can read, look at, and manipulate. Typically the mapping between the abstract data and elements on the screen is implicit in the code: take some piece of the data, do X here, do Y there; when the user clicks on that thing, modify the page here, and so on.

Reasoning about such code is difficult: either control is inverted across many different callbacks with complected concerns, or one must endure a great deal of ceremony with models, controllers, view models, and views/templates to structure an application. Ideally when we build a web application all we should have to do is describe how our application's data should be represented on the DOM. We shouldn't need to worry about callbacks, twiddling the attributes of particular elements, or updating cached state.

As it turns out, ClojureScript's rich data structures and semantics allows us to easily write such simple, declarative code. I will discuss these ideas using examples from visualization-rich dashboard applications.

Recommended reading:

C2: http://keminglabs.com/c2/
Knockout.js: http://knockoutjs.com/
Rich Hickey's talk on the benefits of immutability: http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey

Website
Monday
Jul 2, 2012
PDXScala Meeting
Janrain Headquarters

Come join other Scala enthusiasts to talk about all-things Scala related. Whether you're a newcomer or are writing books on the subject, we welcome you. If you're interested in giving a talk or have a talk you'd like someone to give (we'll do our best to find someone qualified), let us know.

This month, we plan to have presentations and discussions around Akka, actors and futures (both Akka's implementation and others). Come join us if you're interested in these topics or others.

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
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
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
Wednesday
Jan 9, 2013
PDXScala Monthly Meeting
Janrain Headquarters

Come join other Scala fans, whether you're a seasoned oldtimer or complete beginner. We'll have open discussions and a variety of presentations and examples. If you have topics you're interested in hearing more about or something you'd like to give a presentation on, please let us know! Also, feel free to bring code you'd like to show off or get input on from the rest of the group!

This month, we plan to have talks on:

  • Dave Rostron will discuss the new Scala 2.10 reflection library with possible additional material on macros.
  • Kevin Scaldeferri will do a walk through of how Gilt Groupe is using SBT to support development of highly-distributed micro-services architecture.
  • Bryan Armstrong will be doing a presentation on Spray.

We look forward to seeing you there!

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
Wednesday
Feb 13, 2013
PDXScala Meeting
Janrain Headquarters

Come join other Scala fans, whether you're a seasoned oldtimer or complete beginner. We'll have open discussions and a variety of presentations and examples. If you have topics you're interested in hearing more about or something you'd like to give a presentation on, please let us know! Also, feel free to bring code you'd like to show off or get input on from the rest of the group!

This month we'll have talks on Spray, iteratees as implemented in Play and the new SIP-15 value classes.

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
Mar 18, 2013
Clojure/West 2013
through Gerding Theater at the Armory

Clojure/West is a three day conference about the Clojure and ClojureScript programming languages at the Gerding Theater. There will be keynotes by Rich Hickey (Clojure) and Matthew Flatt (Racket) as well as about 35 talks. View the full sessions list.

The conference is $350. Register now!

Website
Tuesday
Apr 9, 2013
Galois Tech Talk: Introducing HERMIT: A Plugin for Transforming GHC Core Language Programs
Galois, Inc

Presented by Andrew Farmer.

The importance of reasoning about and refactoring programs is a central tenet of functional programming. Yet our compilers and development toolchains only provide rudimentary support for these tasks, leaving the programmer to do them by hand. This talk introduces HERMIT, a toolkit enabling informal but systematic transformation of Haskell programs from inside the Glasgow Haskell Compiler's optimization pipeline. With HERMIT, users can experiment with optimizations and equational reasoning, while the tedious heavy lifting of performing the actual transformations is done for them. The talk will explore design choices in HERMIT, demonstrate its use on examples, and seek input for further development and case studies.

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
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
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
Tuesday
Jul 2, 2013
Galois tech talk: SMACCMPilot: flying quadcopters using new techniques for embedded programming
Galois, Inc

Presented by Pat Hickey.

At Galois, we're building critical flight control software using new software methods for embedded systems programming. We will show how we used new domain-specific languages which permit low-level hardware manipulation while still providing guarantees of type and memory safety. The flagship application for these new languages is called SMACCMPilot, a clean slate design of quadcopter flight control software built on open-source hardware. This talk will introduce our new software methods and show how we built SMACCMPilot to be high assurance without sacrificing programmer productivity.

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
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 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
Saturday
Oct 19, 2013
PNWScala
through Leftbank Annex

Come join other Scala fans and aficionados in Portland, Oregon for 2 days of talks and open sessions.

The Pacific Northwest Scala Conference is a regional event focusing on short talks about a wide range of Scala-related topics, and will bring together Scala enthusiasts from both the Pacfic Northwest and other areas

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
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
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
Wednesday
Apr 16, 2014
Introduction to Elixir from a Ruby, Python and Javascript perspective
CrowdCompass office in the Ford Building

We are the Portland Erlang and Elixir meetup.

Matthew Lyon will give an “Intro to Elixir” presentation from and for the perspective of people coming from scripting languages such as Ruby, Python, and Javascript.

Elixir is a functional, meta-programming aware language built on top of the Erlang VM. It is a dynamic language with flexible syntax and macro support that leverages Erlang's abilities to build concurrent, distributed and fault-tolerant applications with hot code upgrades.

José Valim is the creator of the Elixir programming language. His goals were to enable higher extensibility and productivity in the Erlang VM while keeping compatibility with Erlang's tools and ecosystem.

We've also secured a free month subscription to Elixir Sips (http://elixirsips.com/) for everyone. Elixir Sips releases two videos every week to help you get started learning Elixir and keeping up with new tools and libraries. Feel free to pass the link along to anyone you know who might be interested.

Offer expires May 16th: https://elixirsips.dpdcart.com/subscriber/add?plan_id=176&plan_term_id=376

Mexican food from Los Gorditos will be provided. Vegan and gluten free options available. Email [email protected] if there is something specific you'd like to try from their menu: http://www.losgorditospdx.com

We look forward to seeing you!

  • Steve Peters
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
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
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
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
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
Wednesday
Jul 23, 2014
Erlang meetup / Birds of a Feather
Oregon Convention Center

(NOTE: OSCON Birds of a Feather sessions are open to all in the community. You do not need to be registered for the conference to attend.)

As part of OSCON Francesco Cesarini will be leading an Erlang Birds of a Feather gathering at the Oregon Convention Center.

It's an opportunity to meet and greet other functional programming people and discuss how to get things done in the real world that demands highly available, fault tolerant, never-stop systems in heterogeneous environments.

Come prepared to talk and learn!

Also in attendance will be Erlang co-creator Robert Virding and other notable Erlang experts.

http://www.oscon.com/oscon2014/public/schedule/detail/37674

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
Tuesday
Oct 21, 2014
Galois tech talk: Functional programming in Swift
Galois, Inc

Galois is pleased to host the following tech talk. These talks are open to the interested public–please join us! (There is no need to pre-register for the talk.)

abstract: At this year’s WWDC, Apple announced Swift, a new programming language for iOS and OS X development. In this talk, I’d like to give a brief overview of the language, focussing on its ‘functional features’. I’ll try to demonstrate that there are exciting new possibilities for applying functional programming technology to a new platform — like writing an app that computes Fibonacci numbers without using a for-loop.

bio: Wouter Swierstra is a lecturer at the University of Utrecht. He has recently written a book, Functional Programming in Swift, together with Chris Eidhof and Florian Kugler.

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
Tuesday
Nov 11, 2014
Portland ReactJS Hang Session
Lucky Labrador Brew Pub

We recently started a user group for Portland ReactJS users. I'd like to have an informal meet and greet to get to know the community here and get some input from you all on what you'd like to get from this user group and some of our ideas. We hope to have our first official meeting in January/February 2015.

We have a website here (WIP, don't judge :)) and a meetup group at meetup.com. Please Join our meetup group and RSVP if you can so we have an idea of how many people might be attending.

Website
Friday
Nov 14, 2014
PNWScala
through Leftbank Annex

Come join other Scala fans and aficionados in Portland, Oregon for 2 days of talks and open sessions.

The Pacific Northwest Scala Conference is a regional event focusing on short talks about a wide range of Scala-related topics, and will bring together Scala enthusiasts from both the Pacfic Northwest and other areas

Website
Wednesday
Dec 3, 2014
Learning Erlang made me a better engineer and architect
SnapFlow

Nathan Aschbacher throws down on his favorite Erlang topic:

Learning Erlang made me a better engineer and architect.

Even if you don't think you have a use-case for Erlang, don't have an interest in functional programming, and find reading Prolog inspired syntax directly proportional to your increased consumption of Excedrin... according to Nathan Aschbacher (currently Chief Architect at Snapflow and previously Principal Consulting Architect at Basho) you should learn Erlang anyway.

Nathan will be presenting on his path to Erlang and functional programming, his initial disdain, his later begrudging respect, and finally his eventual love and nostalgia for all things Erlang-y.

Join us and share in the conversation.

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
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
Wednesday
Jan 21, 2015
Expand your Knowledge with The Erlang Games
Renewable Funding

This month Casey Rosenthal will lead us through the first session of his Erlang Games. Both beginners and experts alike will have a chance to match brains against seemingly easy problems and learn new and surprising approaches.

Join us and expand your knowledge of Erlang and computing in general!

We will be putting hands-on-keyboards for coding.

If you don't already have Erlang installed on your favorite geekbox, quick instructions can be found here: http://learnyousomeerlang.com/introduction#what-you-need

Learn more about Casey and his wisdom here: www.linkedin.com/pub/casey-rosenthal/84/24b/163

Here's the relevant page on Meetup: http://www.meetup.com/Portland-Erlang-User-Group/events/219563465/

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

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
Tuesday
Feb 10, 2015
Portland ReactJS meetup
Idealist.org

Greetings fellow Reagents!

We are looking forward to our first official ReactJS user group. Dave and Eric from Idealist.org will be sharing some interesting stuff (details below) with us, and we're hoping to have one additional talk. Please let us know if you're interested in speaking/presenting. We'd like to have at least a few lightning talks as well. I have a feeling this will fill up fast, so please RSVP if you would like to attend this event.

If you are new to our group, Welcome! If you would like to get more involved or hear what we're talking about, we'd like to invite you to join our google group to join the conversations or start a new one. Also, please take a look at our code of conduct which let's you know what we think "being excellent to each other" should look and feel like.

Talks:

Notes on the Design of Components (Dave McCabe)

Dave will discuss what idealist.org has learned about designing React components, specifically techniques for promoting simplicity, reuse, statelessness, and separation of concerns, and for dealing with asynchrony.

Isomorphic Webpack Hot Module Replacement Boilerplate (Eric O'Connell)

  • Do you want to serve fully-rendered HTML from your React application?
  • Do you want near-instant feedback in your browser as soon as you edit your React components?
  • How about CSS?

This talk will give the starting point for a very nice dev environment using the webpack Hot Module Replacement feature. It will include a (trivial) Express app that renders the entire React component hierarchy which will then be hydrated on the client. Variations shown will include serving API requests out of the same app, and shared client/server routing.

TBD / Lightning talks

Get in touch with us if you'd like to share your experiences!

Website
Wednesday
Feb 25, 2015
The Erlang Games - 2nd Session
CrowdCompass by Cvent

The Erlang Games continue!

Nathan Aschbacher will lead us through a series of hands-on programming problems that will get your hands dirty in code.

Designed to be instructive and entertaining for both the n00b and experienced erlangutang, join us and expand your skills!

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

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
Tuesday
Mar 10, 2015
Portland ReactJS Presentation night
Jama Software (New Office)

Greetings to all!

We're excited to announce our second meeting and presentation night! We already have some great talks lined up from Dave McCabe and Asa Miller. We're hoping to set aside some time for lightning talks as well. Please join the mailing list and let us know if you are interested in presenting or participating in lightning talks.

Jama Software will be hosting us at their new office in downtown Portland. Catering will also be provided, more details on that soon.

== Proposed Schedule ==

Using React with Real-time data from Firebase. (Asa Miller)

Asa will discuss setting up real-time communication between desktop and mobile and how to to configure it for communication between components instead of passing props.

Notes on the Design of Components. (Dave McCabe)

A discussion on what we've learned about designing React components: Techniques for promoting simplicity, reuse, statelessness, and separation of concerns, and for dealing with asynchrony.

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

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
Tuesday
Apr 14, 2015
Portland ReactJS Presentation night
Jama Software (New Office)

Greetings Reagents!

We had an awesome meetup at Jama with some great talks. Thanks to everyone that took time from their schedule to come out.

We're still looking for some talks from the Portland community. Please let us know if you'd be interested in speaking at this or any future meetings. We have some things brewing for the May meetup that we're excited to share with you next month.

Jama Software has graciously offered their event space again for this meeting. Food will also be provided by Idealist.org, please come at 6pm to enjoy some dinner and socializing.

Presentations will start promptly at 6:30.

== Proposed Schedule ==

• Observables and React (or, 'Yo dawg, I heard you like reactive programming, so I put some Reactive Extensions in your React so you can react while you React’) - (Ian Irvine)

Ian takes us on a tour of JavaScript Observables via RXJS, and explores some potential use cases within the realm of React.

• TBA!!!

Some members have mentioned wanting to see and hear a talk on a rewrite of an app from [something] to React. Have you done this? You should talk about it! Are you interested in trying this? Try it! Then show us how it went.

Website
Wednesday
Apr 15, 2015
Portland Erlang / Elixir Meetup
Lucky Labrador Brew Pub

Daniel Hedland of CrowdCompass will be leading April's meeting.

Learn more about how Unix shells compose simple programs to solve complex tasks and how these processes interact with each other under the hood. We will discuss how Unix processes behave compared with standard Erlang and Elixir processes and how the Erlang VM could be used to emulate common patterns found in the Unix shell.

A very basic REPL will be provided to play around with some of these ideas. After the discussion, we will break out into groups to try to re-implement some common Unix commands in your favorite ErlangVM-based language and then use shell composition to solve a set of everyday problems.

Questions?

[email protected] 503-575-0815

Website
Saturday
Apr 18, 2015
Clojure/West
through Gerding Theater at the Armory

One of the two largest Clojure conferences held each year in the US, Clojure/West offers two days of training workshops followed by three days of talks. Also there are unsessions happening in the evenings.

Follow @clojurewest for updates.

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

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
Tuesday
May 12, 2015
Portland ReactJS Presentation Night
Jama Software (New Office)

Hello all!

We had an awesome meetup last week at Jama with some great talks. Thanks to everyone that took time from their schedule to come out.

In May, we're very excited to announce that Areeb Malik from Facebook's Ads Team will be presenting his talk, "Going Big with React", which will focus on the strengths of a unidirectional data flow architecture in apps with several engineers and megabytes of client-side code. Here is a link to this talk from last year. Areeb will be catering this talk to our React users community here, so please come prepared to ask questions and expect an interesting conversation after his talk.

Jama Software has graciously offered their event space again for this meeting. Food will also be provided by Idealist.org, please come at 6pm to enjoy some dinner and socializing.

The presentation will start promptly at 6:30.

Looking forward to a great meetup! Please RSVP at meetup.com so we know how many people are coming. Thank you!

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

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
Wednesday
Jun 17, 2015
10 Billion a Day, 100 Milliseconds Per: Monitoring Real Time Bidding at AdRoll - Portland Erlang / Elixir Meetup
eBay Community Lounge

10 Billion a Day, 100 Milliseconds Per: Monitoring Real Time Bidding at AdRoll

Brian Troutwine of Adroll will be joining us tonight. Adroll uses Erlang to power their high-speed, never-stop online advertising services. That's right, 10 billion transactions a day.

Brian's talk will provide motivation for the extensive instrumentation of complex computer systems and make the argument that such systems are essential. This talk will provide practical starting points in Erlang projects and maintain a perspective on the human organization around the computer system. Brian will focus on getting started with instrumentation in a systematic way and follow up with the challenge of interpreting and acting on metrics emitted from a production system in a way which does not overwhelm operators’ ability to effectively control or prioritize faults in the system. He’ll use historical examples and case studies from my work to keep the talk anchored in the practical.

Talk objectives:

Brian hopes to convince the audience of two things:

• monitoring and instrumentation is an essential component of any long-lived system and

• it's not so hard to get started, after all.

He’ll keep a clear-eyed view of what works and is difficult in practice so that the audience can make a reasoned decision after the talk.

Website
Thursday
Jul 2, 2015
Clojure PDX Office Hours
Puppet

Intersted in learning more about Clojure? Have questions or need help with a set up, library or Clojure/Functional Programming concept?

Come by the Office Hours meeting this month.

Bring any questions you may have or topics on your mind and we'll see how others can help.

Website
Wednesday
Jul 15, 2015
Portland Erlang / Elixir Social Hour
Lucky Labrador Brew Pub

It's summertime in Portland! Rather than work our brains too hard in the heat, let's just get together, socialize, chat and show off anything we happen to be working on.

Meetup with us at the Lucky Lab on SE Hawethorne. Look for the Erlang laptop stickers!

We'll get back to having speakers in September.

Stay tuned for news about Erlang at OSCON.

Website
Wednesday
Sep 16, 2015
Erlang/OTP at the Jedi Temple
Househappy

If you've heard of Erlang, perhaps you've also seen the acronym "OTP". What the heck is "OTP" and why do the Jedi refer to it as the "magic" that gives Erlang it's reputation for scalability and fault tolerance?

Why is it called Erlang/OTP? What gives? How does this relate to Elixir? What should I know about it?

Nathan Aschbacher of Visa and Elixir Games PDX has kindly agreed to join us and share his wisdom, give us an overview and also, to levitate R2D2.

Our generous hosts this month are HouseHappy.

October we followup on this deep topic with Jeff Weiss showing self-healing application magic in Elixir and OTP. Hope to see you there!

  • Steve
Website
Erlang/OTP at the Jedi Temple
Househappy

If you've heard of Erlang, perhaps you've also seen the acronym "OTP". What the heck is "OTP" and why do the Jedi refer to it as the "magic" that gives Erlang it's reputation for scalability and fault tolerance?

Why is it called Erlang/OTP? What gives? How does this relate to Elixir? What should I know about it?

Nathan Aschbacher of Visa and Elixir Games PDX has kindly agreed to join us and share his wisdom, give us an overview and also, to levitate R2D2.

Our generous hosts this month are HouseHappy.

October we followup on this deep topic with Jeff Weiss showing self-healing application magic in Elixir and OTP. Hope to see you there!

  • Steve
Website
Wednesday
Oct 21, 2015
Chat Bot Deathmatch! - Portland Erlang and Elixir Meetup
Househappy

Jeff Wiess will share his presentation from ElixirConf EU and give us a live demo:

Chat Bot: A Practical Walkthrough of the powerful Features Elixir/Erlang/OTP

Bring your laptop and be ready to help us try and crash Jeff's chat server service.

Written in Elixir, a "Ruby-like" flavor of Erlang this demo will show supervision trees, clustering and live code updating.

Our generous hosts this month are HouseHappy.

Website
Wednesday
Nov 18, 2015
A Noob's Guide to Multiplayer Game Development in Elixir
Househappy

Take a break from League of Legends to learn how to create multiplayer games of your own. Michael Matyi of Househappy will share his experiences in writing a multiplayer game server using Elixir and OTP principles. A variety of topics will be visited, including DSLs, socket communication and streams.

Bring your laptop! There will be an interactive demo to help illustrate the concepts in this talk.

Questions? [email protected]

Website
Thursday
Dec 3, 2015
Clojure Office Hours - Special Newcomers Edition
Puppet

Office hours are a great place to chat with other developers and help or get help with any questions that come up.

Everyone is always welcomed regardless of skill or experience. If you curious come on out.

This month we'll have a special newcomers focus where we'll start with introductions, have lighting talks, discuss somethings we like about clojure and some things we find confusing and help each other install a dev environment.

Curious about Clojure? Have questions about Emacs or Cursive or Vim or Spacemacs or anything else? Come on out and we'll help.

Website
Thursday
Jan 7, 2016
Clojure PDX - Ibis: a Journey in Distributed Computation w/ Ryan Spangler
Puppet

Recently we at Little Bird had a series of issues trying to get another Clojure distributed computation library working in production. Learning from the frustrations involved in that process clarified exactly what we wanted out of a distributed computation system, and soon after Ibis was born. The goal was to simplify everything and leave the hard problems of synchronization to battle tested libraries that already do it well, namely Zookeeper and Kafka. Built on this solid foundation, Ibis was a natural expression of our intent when designing a distributed system. Providing seamless distribution in the face of adding and removing nodes on the fly, streaming, scheduling and unique tasks, Ibis is already serving us well in production and we consider it a great success.

Website
Wednesday
Jan 20, 2016
Flying with Phoenix and Elixir
HouseHappy.org

Have you heard of Phoenix? Phoenix is a framework for building HTML5 apps, API backends and distributed systems. Written in Elixir.

http://www.phoenixframework.org/

Seve Salazar of HouseHappy.org will walk us through creating a simple but real(wish)-world JSON API using Phoenix and deploying it to production as an OTP application. It will cover usage of Ecto, rendering JSON from a controller, integrating with StatsD using Exometer, and finally using edeliver to ship it to production.

Website
Wednesday
Mar 23, 2016
Elixir Games PDX - Get in the Zone
Puppet

We parted ways from the normal format of this meetup last time, and instead of working on the problem stated, we ended up working on trying to get a relatively complex Erlang project (erl-dns) to build using only Elixir's build chain as well as added an Elixir module to the project to ensure that we could attempt to extend the project using only Elixir code.

This month we'll continue the games format, but instead of a contrived problem we'll continue down this path of modifying and contributing to an open source project.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet Labs, ‘the leader in IT automation’, for hosting us.

Website
Wednesday
Apr 20, 2016
VoIP, Kazoo and Erlang
HouseHappy.org

James Aimonetti of 2600hz.com will be joining us tonight to talk about how Erlang powers the Kazoo project and Voice-over-IP products all around the world.

Kazoo is a scalable, distributed, cloud-based telephony platform that allows you to build powerful telephony applications with a rich set of APIs.

Designed to handle anything from large carrier to small countries, the Kazoo infrastructure can do it all. There are no lock-ins and the software is open-source to give you complete freedom.

James will be giving us a high level view of the architecture behind Kazoo, both from a platform perspective and from an Erlang perspective. We'll survey some of the code that is of interest, such as the gen_listener behaviour (for AMQP message consumption), the PropEr tests in various modules, the wh_json module for working with Erlang-encoded JSON objects), and more. No telecom experience required!

Website
Wednesday
Apr 27, 2016
Elixir Games PDX - As With All Things, It's All About the Atoms
Puppet

This month we'll be continuing down the path of analyzing and modifying a production-grade open source project. Last month many people who attended were able to discover where in erl-dns our custom zone-file handling code should go. This month we'll drive toward a real replacement implementation to take the next step toward being able to make incremental zone updates and pave the way toward DNS-SD functionality.

This month we'll continue the games format, but instead of a contrived problem we'll continue down this path of modifying and contributing to an open source project.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet Labs, ‘the leader in IT automation’, for hosting us.

Website
Thursday
May 5, 2016
Lightning talks and office hours
Puppet

Our scheduled speaker had to cancel unexpectedly so we'll have lighting talks and office hours.

The talks don't need to be formal at all. Just take 5-15 minutes sharing something you've learned or are working on.

To get the ball rolling I'll do:

"What I've learned about React Native and ClojureScript"

So what have you been working on? Don't be shy. Your group needs you.

And as for the office hours ... just come with your questions, problems and challenges and we'll try to help.

Thanks.

Julio

Website
Wednesday
May 25, 2016
Elixir Games PDX - Many Types of Success, But Only One Success Type
Puppet

NOTE: Please RSVP via the meetup.com website, it helps for food and beverage planning.

Last month we had a really varied mix of experience levels in attendance, and so this month we'll cover a subject that will be useful to audiences and participants of all shapes and sizes... Dialyzer & TypeSpecs. Elixir isn't a statically typed language, but thanks to TypeSpecs and Dialyzer we can do static type analysis and avoid whole horrible classes of runtime errors by checking our code at compile-time.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet Labs, ‘the leader in IT automation’, for hosting us.

Website
Thursday
May 26, 2016
Erlang On NixOS - Managing And Releasing Erlang Systems In The Cloud
HouseHappy.org

Erlang On NixOS - Managing And Releasing Erlang Systems In The Cloud With A Fully Declarative Package Manager

In this talk we will discuss how to manage Erlang dependencies with the Nix package manager and how to use the Nix system to deliver declaratively described images containing an Erlang Release to cloud platforms.

Talk objectives:

To educate the audiance about the value of using a functional, declarative package management system to deliver functional, declarative systems.

Target audience:

Developers actively deploying Erlang systems and those interested in deploying Erlang System.

About Eric Merritt

Co-author of Erlang and OTP in Action, open source contributor, Erlang Engineer.

Website
Monday
Jun 20, 2016
Hacking Web Stuff with F#
Lucky Labrador Tap Room

Ok, F#ers, got a special guest coming into town that would like to do some web stuff hacking, and thus...

Hacking Web Stuff with F#

In this hands on session, we'll have a look at two F# libraries for doing web stuff, both on the server-side and on the client-side. It will be hands-on, so make sure to bring a laptop with F#. For playing with Fable, you'll also need to have node installed! Suave for the server-side

Suave is a lightweight web-server for F# that lets you compose web applications or REST services from small, correct, asynchronous web parts. It lets you compose asynchronous web services with just a couple of lines of code. For more information check out www.suave.io or demos like the F# snippes web site.

Fable is an F# to JavaScript compiler that lets you use functional-first programming style on the web. It produces modern and clean JavaScript with minimal core library and source maps. It integrates well with modern JavaScript dev tools like node, WebPack and organizes code using ES6 modules.

Tomas is a computer scientist, book author and open-source developer. He wrote a popular book called "Real-World Functional Programming" and is a lead developer of several F# open-source libraries, but he also contributed to the design of the F# language as an intern and consultant at Microsoft Research. He is a partner at fsharpWorks (http://fsharpworks.com) where he provides trainings and consulting services. Tomas recently submitted his PhD thesis at the University of Cambridge focused on types for understanding context usage in programming languages, but his most recent work also includes two essays that attempt to understand programming through the perspective of philosophy of science.

Website
Wednesday
Jun 22, 2016
Elixir Games PDX - Every step you take, every proc you break... we'll be watching you.
Puppet

Elixir inherits a tremendous suite of debugging, tracing, and monitoring facilities from its Erlang pedigree, where the use case was something shaped like, "Be able to attach to, live trace, muck with, and live zero-down-time upgrade this service running on a thing dangling from a 10m pole in the backwoods of Siberia." In this month's meetup we'll take a look at some of these tools and use them to poke around some running services.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet, ‘the leader in IT automation’, for hosting us.

Website
Wednesday
Jul 27, 2016
Elixir Games PDX - Exit GenStage Left.
Puppet

The Elixir language and standard library is always in a state of diligent improvement, and in accordance with that trend GenStage was recently added. GenStage is a core generic behavior designed to provide a way of coordinating communication between processes with built-in back-pressure. This month we'll take a closer look at what this is, what problems its intended to solve, and exercise the functionality a bit to see how to use it for real-world-shaped problems.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet, ‘the leader in IT automation’, for hosting us.

Website
Wednesday
Aug 24, 2016
Elixir Games PDX - Plenty of Blame to go Around
Puppet

We've looked at Supervision trees in the past, but we've often glossed over how to best use them to your advantage. It's quite easy to accidentally use these fault-tolerance primitives to, somewhat ironically, make your applications less fault-tolerant. This month we'll take a look at design and implementation practices to help make sure you're using these incredible tools to your best advantage.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet, ‘the leader in IT automation’, for hosting us.

Website
Saturday
Sep 17, 2016
2-day workshop: Advanced Redux/Async
through Epicodus

Image Logo - Advanced Redux: A 2-day workshop from Real World React

Note: this is a paid event. You can purchase tickets at https://universe.com/advancedredux

You've learned React, and are excited about building robust, scalable applications. But at some point your application is going to become too complex for React to handle on its own. How do you effectively manage each component and their states? Enter Redux.

Redux has fast become the architecture of choice for building scalable applications with JavaScript and React. It will help you to better organize your application and make state mutations more predictable and transparent.

In this advanced workshop, FreeCodeCamp CTO Berkeley Martinez will help you to take your development skills to the next level.

What you will learn

Saturday - Sunday:

  • Using Redux Middleware
  • Managing Asynchronicity
  • Dispatching Thunks and Promises
  • Using Redux with RxJS Observables
  • Analytics with Redux
  • Server Side Rendering using RxJS Observables

What we will build

We will apply the principles above as we build a social e-commerce app, complete with:

  • Search and Filtering
  • User authentication
  • Likes
  • Follows
  • Shopping Cart

Your Instructor

Berkeley Martinez, CTO of FreeCodeCamp.com

An image of Berkeley Martinez

Berkeley is the CTO of freecodecamp.com, a free online community for learning full-stack web development where students garner real-world experience by engineering solutions for nonprofit companies. He has been programming with React for over two years, and is the author of Redux-Epic, a library built to do better async and server-side rendering in React with RxJS Observables. He is also the co-organizer of the San Francisco-based Meetup group Real World React, which features talks and workshops on using React in real-world, production applications. As an instructor at Real World React, he consults individuals and businesses looking to become experts in React, Redux, and other tools in the ecosystem.

Prerequisites

  • Familiar with React.js
  • Understands fundamentals of Redux
  • Comfortable with HTML, CSS, and JavaScript
  • Familiar with ES6 Syntax (not an exhaustive list)
    • Arrow Function syntax
    • Spread/Rest
      • And using them to change objects/arrays without mutation (immutable methods)
    • Promises
    • Class syntax
    • Module syntax
  • Comfortable with the command line & NPM
  • Comfortable building with React and React-Router
  • Comfortable with the concepts of functional programming.

Pre-class Resources

  • Follow the link above to the event website -- Calagator limits the amount of links we can post

Your Organizer

Real World React is an SF-based organization that features talks, meetups, and workshops on using React & Redux in real-world, production applications.

Website
Wednesday
Sep 28, 2016
Elixir Games PDX - Architecture: It's Not Just for Skyscrapers
Puppet

This month we're going to take a look at the architecture of a couple open source Elixir libraries, talk about them, how they fit with OTP principles that Elixir inherits from the Erlang ecosystem, and devise a strategy for how to bring the existing design into line with a more OTP-y way of doing things. We'll also discuss why that's valuable or desirable and start to iterate on making those changes together.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet, ‘the leader in IT automation’, for hosting us.

Website
Thursday
Oct 6, 2016
Talk 1) Game/DEVS by Austin Haas & Talk 2) Spec/Regex by Russell Mull
Puppet

We'll have two talks this month.

Making Games in Clojure(script) with the DEVS Modeling Formalism

In this talk, Austin Haas will discuss why games are difficult to make and how DEVS, a popular simulation modeling formalism, can help. This talk may be relevant to anyone interested in game development, systems theory, actors, agents, or FRP.

Regex derivatives: the functional pearl inside core.spec

The new spec library in Clojure 1.9 uses an old but elegant method for recognizing sequences. We'll develop an implementation of this algorithm in Clojure.

Bio: Russell writes Clojure at Puppet. He's into guitars and separating his functions from his data.

Website
Wednesday
Oct 26, 2016
Elixir Games PDX - Interproconal Communication Skills
Puppet

Elixir and Erlang make tremendous tools for integrating between different kinds of interfaces. In fact there's arguably no better system for quickly constructing reliable and fault-tolerant control planes available today. However, in order to do that in a rich ecosystem of technologies it is a requirement that we be able to interact with and orchestrate various kinds of external processes. So for this meetup session we're going to learn about exactly how to do that.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to our friends at Puppet, ‘the leader in IT automation’, for hosting us.

Website
Tuesday
Nov 1, 2016
Using Ports in Elm
Jaguar Land Rover Tech Incubator

So you're using Elm and enjoying all of the benefits it provides with its abstraction of the web platform. But what do you do if you're dealing with a browser API that isn't implemented in Elm yet? Or you need to ship a feature and don't have the time to rewrite that really cool JavaScript library in Elm? Or maybe you want to hook your app up to Firebase or some other database that has a JavaScript SDK?

This is where ports come in. Ports allow you to hook up commands and subscriptions to JavaScript code, letting you leverage the entire JavaScript ecosystem, while providing the structure necessary to ensure you aren't introducing runtime exceptions in your Elm code.

We'll cover the basics of setting up ports in your Elm code, walk through some common use cases, and hopefully you'll leave the evening ready to bring your JavaScript and Elm knowledge together!

Ben Brandt lives in Portland and is a front-end developer at Monk Development. He has recently discovered the joys of using functional programming for building UI's and is trying to use Elm wherever people will let him.

Website
Wednesday
Nov 30, 2016
Elixir Games PDX - Learning to Love Property Tax
Puppet

Many developers are probably familiar with unit-testing, and probably a few even rigorously utilize it, but software validation exists on a spectrum ranging from formal verification to nothing at all. Unit-testing tends to reside a lot closer to the empty abyss side of that spectrum in-practice, so what methods and tools can we use to start inching (centimetering, for the internationally inclined) closer to the other side? To get to a point where we're brimming with confidence about our design and implementation? Property-Based Testing can be the next step on that journey, and this month we'll take a look at one of Elixir's PBT frameworks and use it to validate a bit of code.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to our friends at Puppet, ‘the leader in IT automation’, for hosting us.

Website
Monday
Dec 12, 2016
Portland Functional Programming Study Group - Functional Discussions
Collective Agency Website
Wednesday
Jan 25
Elixir Games PDX - You're Getting On My Nerves
Puppet

Bridging the gap between higher-level application development and embedded device deployments is all the rage these days. As is the case with the much of the rest of the Elixir ecosystem, there's a project to help make such ambitions a lot more friendly and inviting to work with (http://nerves-project.org/). This month we'll be taking a look at this project, explore a handful of similar alternative approaches to the same problem, and see if we can get some simple distributed Elixir applications running and communicating as Nerves apps.

If you have any of the supported hardware (referenced below), then by all means bring it with you and we'll see if we can get things working on real hardware. All the organizer's embedded SBCs are Odroid C2's, which aren't Nerves-compatible, so we won't be able to supply hardware for the whole group, but for those that don't have hardware to deploy to we can still build QEMU ARM images and run them in an emulated VM environment.

Supported Hardware:

https://hexdocs.pm/nerves/targets.html

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to our friends at Puppet, ‘the leader in IT automation’, for hosting us.

Website
Wednesday
Feb 1
Portland F# Meetup Group - Organizational Meeting
DAT

I need to double-check with the location's availability still, but I'm pretty sure they'll be able to accommodate us.  I'll also have an update with instructions on how to enter the building after hours.

At this meetup, we need to identify and empower a new organizational team. 


I'm recommending that we have four active members with the privileges to schedule and conduct meetups.  This should distribute the burden of identifying topics, picking dates and times and securing locations in such a way that we capture productivity at the moment of inspiration and not obligation.  If that last bit didn't make sense, come to the meetup and I'll explain how that works.


 

Website
Monday
Feb 20
Portland Functional Programming Study Group - Haskell Lesson 1 and Data Parallelism
Collective Agency

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
Wednesday
Feb 22
Elixir Games PDX - Traitorous Protocol Droids
PolySync Technologies, Inc.

Similar to traits in other languages, Elixir Protocols are contracts that modules can implement for enabling collections (both sinks and sources) and inspection. We'll take a look at Protocols, how to adhere to them and how to create them.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Venue Change: Now at PolySync.

Website
Erlang-Elixir - Moving Complexity Around
Househappy

Jesse Cook will lead our exploration tonight.

Jesse: A beginner Alchemist who's really enjoying the functional nature of Elixir and the design of the language.

Description: Moving complexity around - What's the best way to provide a unified API in front of some of the worst APIs out there? The tools I reached for are Phoenix, Absinthe for GraphQL and a series of adapters. These adapters utilize both polymorphism and metaprogramming, but was this the right way to do it in Elixir? Let's discuss the overall architecture and the nitty gritty details.

Website
Thursday
Mar 2
Clojure Collection Processing in Context w/ Bill Burcham
Puppet

Part I: Eager to Process

A key innovation in Clojure (versus earlier Lisps) is the abstraction of sequence processing functions away from the list type, to the more general sequence interface. This polymorphic abstraction lets what would otherwise be a large library of functions operating on a single collection type (list), grow in power to operate over more collection types, including maps, sets, vectors, and many others.

The clojure.core sequence processing facilities borrow great ideas from earlier Lisps and Haskell too. Conversely, ClojureScript’s collections library can be viewed as a successor to Clojure’s own. By exploring a little bit of this surrounding terrain, we gain a much clearer understanding of Clojure’s elegant and powerful collection processing.

In this first 45-minute presentation, we’ll introduce a toy problem and we’ll solve it a few different ways at the REPL. From very basic beginnings, we’ll introduce sequence processing and collection-sequence duality. We’ll progress smoothly to higher-order functions and beyond (I don’t want to ruin the surprise mkay?) Along the way we’ll meet a number of foundational Clojure functions and forms.

If you’ve read a Clojure book (mainly the first few chapters) and you’ve written some code, you have everything you need to understand this talk. Intermediate Clojurists, may also come away with some new insights.

Bio:

Bill Burcham has earned his living for almost three decades now, making software. He’s liked Lisp best for even longer than that. As many have pointed out: Lisp feels like something discovered—not something invented. There is something essential in Lisp.

When he’s not engaged in a media fast, Bill can be reached @billburcham

Website
Monday
Mar 13
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
Wednesday
Mar 29
ClojureScript: I Can't Believe It's JavaScript
eBay Community Lounge

There are 6 difficult problems frameworks and libraries try to solve in JavaScript, but never quite get there. Learn how these problems (and more!) are solved by ClojureScript and how it can provide a platform for new solutions.

Are you tired of constantly chasing after the next framework? Do you ever feel like frameworks don't solve the hard problems, like callback hell, state management, and correctness checking? Are you looking for something that could make your software radically simpler and let you code better features? ClojureScript could be the answer. In this talk, you'll learn how ClojureScript solves really some tough problems in JavaScript and how it provides a platform for new solutions.

Note: This is a special edition meeting at a different time and place than normal

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

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
Saturday
May 6
Programming Languages I've Been Meaning To Try But Haven't Gotten Around To Yet
Simple

PLIBMTTBHGATY is a lightly-structured party where people get together and work on a project in a new programming language, either with or just near each other.

Website
Monday
May 8
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
Jun 19
Portland Functional Programming Study Group - Haskell Lesson 5 and the 1ML Language
Collective Agency

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