Viewing 0 current events matching “haskell” by Event Name.
Sort By: Date | Event Name, Location , Default |
---|---|
No events were found. |
Viewing 77 past events matching “haskell” by Event Name.
Sort By: Date | Event Name, Location , Default |
---|---|
Tuesday
Nov 3, 2009
|
Galois Talk: Testing First-Order-Logic Axioms in AutoCert – Galois, Inc The next talk in the Galois Tech Seminar series:
For details (including an abstract and speaker bio), please see our blog post: http://www.galois.com/blog/2009/10/28/ahn-autocert/ An RSVP is not required; but feel free to drop a line to [email protected] if you've any questions or comments. Levent Erkok |
Wednesday
Sep 20, 2017
|
Beaverton Haskell Meetup – Oregon Technology Buisiness Center (OTBC) Bring whatever Haskell project you happen to be working on and we'll spend a couple hours helping each other with them. |
Monday
Jul 31, 2017
|
Beaverton Haskell Meetup - Haskell Projects – Oregon Technology Buisiness Center (OTBC) It's been a while since I've updated the description for this meetup's events. So, the group originally started to learn Haskell from scratch. The group agreed that we would each choose our own learning materials to work from during the week and then come together during the meeting to discuss and work on programming exercises together. Since then we have started working on larger projects in Haskell and are starting to investigate more advanced features of the language. If you have something that you've been working on that you would like to share or you would like to help someone else with their own project then please join us! We're always looking to meet more folks who are interested in the virtues of functional programming. |
Monday
May 8, 2017
|
Beaverton Haskell Meetup - Write You a Scheme 2.0 - Session 1 – Oregon Technology Buisiness Center (OTBC) Hello!
Thanks to everyone who attended the kickoff meeting for this group. It was a really good turn out and looks like there are a lot of folks excited about learning some Haskell. We have decided at this point to meet on a bi-weekly basis Mondays at 6:30pm. We also have a new venue which has been secured at the OTBC offices thanks to Phil for the referral on that one. We have also decided that we will be going through the online tutorial Write You a Scheme 2.0 as our first project. Each person will choose resources on their own to learn Haskell and we will come together as a group in each meeting to talk about our progress on building a scheme interpreter and our understanding of the code presented. Most likely we will also do some Haskell exercises as a group to help solidify new concepts. To prepare for the next meetup go through the introduction and if you have time, the next section on parsers as well. We'll try to cover as much ground as we have time available. We also have a Slack channel that you can join by clicking the link that was sent out on the mailing list. If you need an invite link let me know and I'll get you connected. |
Saturday
Nov 14, 2009
|
Darcs Hacking Sprint through Galois, Inc Who : Anybody who wants to hack on Darcs (or Camp, Focal, SO6, etc) Beginners especially welcome! Why : Darcs aims to have bi-annual hacking sprints so that we can get together on a regular basis, hold design discussions, hack up a storm and have a lot fun. What : We plan to put some finishing touches on Darcs-2.4. Darcs 2.4 is a pretty exciting release because we expect it to offer nice performance enhancements from Petr's Google Summer of Code Project, and also a nice new 'hunk splitting' feature. We also intend to set aside at least one Darcs hacker for mentoring beginners, so if you're new to Haskell or to Darcs hacking, here's a good chance to plunge in and start working on a real world project. How: Add yourself to http://wiki.darcs.net/Sprints/2009-11 |
Tuesday
Jul 23, 2013
|
Functional Programming meetup – With OSCON in town this week, bringing to town many from the functional programming community among others, we thought it would be a good idea to hold a casual functional programming meetup. There's no agenda and no talks, but there will be beer and good conversation. We'll be meeting up on the patio at Green Dragon. If you're just visiting and are worried you won't recognize the geeks when you get there (we're usually easy enough to spot), feel free to ping people on the PDXFunc mailing list (https://groups.google.com/forum/#!forum/pdxfunc) or on IRC at #pdxfunc. |
Monday
Jun 8, 2015
|
Functional Programming Study Group – Collective Agency Downtown Levent Erkok will be giving an informal talk on the SBV library that he's been working on for quite some time now (https://hackage.haskell.org/package/sbv), and a possible brief intro to SAT/SMT solving. |
Tuesday
Oct 20, 2009
|
Galois Talk: Writing Linux Kernel Modules with Haskell – Galois, Inc The next talk in the Galois Tech Seminar series:
For details (including an abstract and speaker bio), please see our blog post: http://www.galois.com/blog/2009/10/13/haskellkernelmodules/ An RSVP is not required; but feel free to drop a line to [email protected] if you've any questions or comments. Levent Erkok |
Tuesday
Jan 10, 2012
|
Galois Tech Talk (1 of 3 next week!): Formalizing Haskell 98 in the K Semantic Framework – Galois, Inc Presented by David Lazar Formal semantics is notoriously hard. The K semantic framework (http://k-framework.org/) is a system that makes the task of formally defining programming languages easy and practical. The primary goals of the K framework are modularity, expressivity, and executability. Adding a new language feature to a K definition does not require you to revisit and modify existing semantic rules. The K framework is able to concisely capture the semantics of non-determinism and concurrency. Each K definition automatically yields an interpreter for the language so that the definition can be tested for correctness. These features made it possible to develop a complete formal semantics of the C language in K. The first half of the talk will be an overview of the K semantic framework. We'll discuss the merits of the framework using the K definition of a complex toy language as a guiding example. The second half of the talk will focus on a work-in-progress formalization of Haskell 98 in K. We'll look at the challenges of formalizing Haskell and the applications of this work. |
Friday
Jan 29, 2010
|
Galois Tech Talk: A Scalable I/O Manager for GHC – Galois, Inc A Scalable I/O Manager for GHC Presented by Johan Tibell. Abstract: The Glasgow Haskell Compiler supports extraordinarily cheap threads. These are implemented using a two-level model, with threads scheduled across a set of OS-level threads. Since the lightweight threads can’t afford to block when performing I/O operations, when a Haskell program starts, it runs an I/O manager thread whose job is to notify other threads when they can safely perform I/O. The I/O manager manages its file descriptors using the select system call. While select performs well for a small number of file descriptors, it doesn’t scale to a large number of concurrent clients, making GHC less attractive for use in large-scale server development. This talk will describe a new, more scalable I/O manager that’s currently under development and that hopefully will replace the current I/O manager in a future release of GHC. Details: Date: January 29th, 2010, Friday Time: 1:30pm Location: Galois Inc., 421 SW 6th Ave. Suite 300 (3rd floor of the Commonwealth building) Bio: Johan Tibell is a Software Engineer at Google Inc. He received a M.S. in Software Engineering from the Chalmers University of Technology, Sweden, in 2007. |
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. |
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. |
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. |
Tuesday
May 10, 2011
|
Galois Tech Talk: Empirical Sampling With Haskell – Galois, Inc Presented by Chad Scherrer. Sampling from a large discrete distribution is a common problem in statistics. In this talk, we'll consider a real-world situation where the properties of the distribution cause common approaches to break down, and we'll arrive at a Haskell-based solution that fixes the problem. |
Tuesday
Feb 15, 2011
|
Galois Tech Talk: Faster Persistent Data Structures Through Hashing – Galois, Inc Presented by Johan Tibell. The most commonly used map (dictionary) data type in Haskell is implemented using a size balanced tree. While size balanced trees provide good asymptotic performance, their real world performance is not stellar, especially when used with keys which are expensive to compare, such as strings. In this talk we will look at two different map implementations that use hashing to achieve better real world performance. The implementations have different performance characteristics: one provides very fast look-ups while the other trades better insert performance for somewhat slower look-ups. I will describe the design of these data structures and show some early benchmark results. |
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. |
Tuesday
Apr 7, 2015
|
Galois tech talk: From Haskell to Hardware via CCCs – Galois Inc abstract: For the last several years, speed improvements in computing come mainly from increasing parallelism. Imperative programming, however, makes parallelization very difficult due to the many possible dependencies implied by effects. For decades, pure functional programming has held the promise of parallel execution while retaining the very simple semantics that enables practical, rigorous reasoning. This talk describes a prototype compiler from Haskell (not a library) to low-level hardware descriptions for massively parallel execution on reprogrammable logic devices. The compiler works by monomorphizing, miscellaneous other transformations, and conversion to the vocabulary of cartesian closed categories (CCCs), as captured in a small collection of Haskell type classes. One instance of those classes provides an interpretation as parallel circuits. I will show many examples of simple Haskell programs and corresponding compiler-generated circuits. bio: Conal Elliott has been working (and playing) in functional programming for more than 30 years. He especially enjoys applying semantic elegance and rigor to library design and optimized implementation. He invented the paradigm now known as “functional reactive programming” in the early 1990s, and then pioneered compilation techniques for high-performance, high-level embedded domain-specific languages, with applications including 2D and 3D computer graphics. The latter work included the first compilation of Haskell programs to GPU code, while maintaining precise and simple semantics and powerful composability, as well a high degree of optimization. Conal earned a BA in math with honors from the College of Creative Studies at UC Santa Barbara in 1982 and a PhD in Computer Science from Carnegie Mellon University in 1990. His latest position was at Tabula Inc, where he worked on chip specification and compiling Haskell to hardware for massively parallel execution until their closure in early 2015. Before Tabula, his positions included Architect at Sun Microsystems and Researcher in the Microsoft Research graphics group. He has also coached couples and led conscious relationship workshops together with his partner Holly Croydon, with whom he now lives on 20 acres in the woods in the California Gold Country. For publications, CV, professional blog, etc, see http://conal.net. |
Tuesday
Mar 15, 2011
|
Galois Tech Talk: Haskell And The Social Web – Galois, Inc Presented by Philip Weaver. Janrain offers user management services that include single sign-on, social login, and profile storage. We have recently begun using Haskell extensively to implement our products, and would like to share what the experience has been like. In this talk we will give a technical demonstration of Capture, whose backend is written in Haskell, discuss some of the implementation details of Capture, and look at some of the joys and pitfalls that we experienced. |
Friday
Jun 13, 2014
|
Galois tech talk: Haskell Bytes – Galois, Inc speaker: Joachim Breitner abstract: We will take you on a guided tour through the memory of a running Haskell program and get to peek at the raw bytes of Haskell values. We’ll see how uniformity allows for polymorphic functions and data structures, where the garbage collector finds the information it needs and learn to predict how large certain values tend to become. With the help of a visualization tool (ghc-vis) we will also see laziness and sharing at work, and reveal the mystery of how Haskell fits infinite data structures into a finite amount of memory. bio: Joachim Breitner is a PhD student at the Karlsruhe Institute of Technology, Germany, where he works on the semantics of lazy functional programming language and on interactive theorem provers. He maintains the Haskell packages for Debian and Ubuntu and contributes to GHC. When he is AFK, he enjoys board games, swing dancing, softball and paragliding. |
Friday
Dec 12, 2014
|
Galois tech talk: Making GHC work for you – Galois Inc abstract: GHC is a state-of-the-art optimizing compiler that is constantly being improved. But despite all of the hard work by the developers, you occasionally find yourself in need of a feature that GHC does not (yet) support. Luckily for us, GHC does have multiple extension points built into the standard compilation pipeline, in addition to exposing its functionality as a library. In this talk I’ll give an overview of GHC’s internal architecture and existing extension points. I’ll also walk through a recent extension I wrote to improve the debugging experience in embedded DSLs. bio: Eric Seidel is a 3rd year PhD student at UC San Diego, where he works on the LiquidHaskell program-verification tool. |
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: ABSTRACT: To the typical engineer or evaluator, mathematics can be scary, logic can be scarier, and really long specifications can simply be overwhelming. This talk is about the problem of the visual presentation of formal specifications clearly and concisely. We take as our initial inspiration Leslie Lamport's brief paper, "How to Write a Long Formula" and "How to Write a Proof" in which he proposes methods for writing the long and tedious formulas and proofs that appear in formal specification and verification. I will describe the problem and present one particular solution, as implemented in a simple pretty-printer I've written (in Haskell), that uses indentation and labels to more easily visually parse long formulas. Ultimately, I propose a "HOL Normal Form" for presenting specifications, much like BNF is used for presenting language definitions. BIOGRAPHICAL DETAILS: http://galois.com/company/people/lee_pike/ ABOUT THE GALOIS TECH TALKS. Galois (http://galois.com) has been holding weekly technical seminars for several years on topics from functional programming, formal methods, compiler and language design, to cryptography, and operating system construction, with talks by many figures from the programming language and formal methods communities. The talks are open and free. If you're planning to attend, dropping a note to [email protected] is appreciated, but not required. If you're interested in giving a talk, we're always looking for new speakers. |
Tuesday
Oct 6, 2009
|
Galois Tech Talk: Roll Your Own Test Bed for Embedded Real-Time Protocols: A Haskell Experience – Galois, Inc The next talk in the Galois Tech Seminar series:
For details (including an abstract and speaker bio), please see our blog post: http://www.galois.com/blog/2009/09/29/pike-haskell0/ Abstract: We present by example a new application domain for functional languages: emulators for embedded real-time protocols. As a case-study, we implement a simple emulator for the Biphase Mark Protocol, a physical-layer network protocol in Haskell. The surprising result is that a pure functional language with no built-in notion of time is extremely well-suited for constructing such emulators. Furthermore, we use Haskell’s property-checker QuickCheck to automatically generate real-time parameters for simulation. We also describe a novel use of QuickCheck as a probability calculator for reliability analysis. Bio: Lee Pike is a member of the technical staff at Galois. Previously, he was a research scientist with the NASA Langley Formal Methods Group, primarily involved in the SPIDER project. His research interests include applying formal methods to safety-critical and security-critical applications, with a focus on industrial-scale endeavors. An RSVP is not required; but feel free to drop a line to [email protected] if you've any questions or comments. Levent Erkok |
Tuesday
Jul 8, 2014
|
Galois tech talk: Sunroof and a Blank Canvas: A tail of two DSLs – Galois, Inc abstract: Sunroof is an embedded Haskell Domain Specific Language (DSL) that compiles to JavaScript. Blank Canvas is an embedded Haskell DSL that provides direct access to the HTML5 JavaScript Canvas. Both DSLs superficially provide the same capabilities, but make different trade-offs in the DSL design space. Sunroof uses monadic reification to enable bindings in the DSL to be translated into bindings in JavaScript, while blank canvas has every binding make a round trip from Haskell, to JavaScript, back to Haskell. In this talk, we will present the specifics of both DSLs, using examples, then use both DSLs to outline the difference choices available when designing and implementing embedded DSLs in Haskell. bio: Andrew (Andy) Gill was born and educated in Scotland, and has spent his professional career in the United States, working both in industry, and academia. Andy received his Ph.D. from the University of Glasgow in 1996, then spent three years in industry as a compiler developer, and a year in academia as a principal project scientist. He co-founded Galois in 2000, a technology transfer company that used language technologies to create trustworthiness in critical systems. In 2008, he joined the University of Kansas, and in 2014 he was a recipient of the NSF CAREER Award. Andy believes that functional languages like Haskell are a great medium for expressing algorithms and solving problems. Since returning to academia, he has targeted the application areas of telemetry and signal processing, specializing in generating high performance circuits from specifications. His research interests include optimization, language design, debugging, and dependability. The long-term goal of his research is to offer engineers and practitioners the opportunity to write clear and high-level executable specifications that can realistically be compiled into efficient implementations. |
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. |
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:
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.
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. |
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' patchtheory 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. |
Monday
Jul 29, 2013
|
Galois tech talk: Type-directed compilation in the wild: Haskell and Core – Galois, Inc Academic papers often describe typed calculi, but it is rare to find one in a production compiler. Indeed, I think the Glasgow Haskell Compiler (GHC) may be the only production compiler in the world that really has a remorselessly statically-typed intermediate language, informally called "Core", or (when writing academic papers) the more respectable-sounding "System FC". As real compilers go, GHC's Core language is tiny: it is a slight extension of System F, with letrec, data types, and case expressions. Yet all of Haskell (now a bit of a monster) gets translated into it. In the last few years we have added one new feature to Core, namely typed (but erasable) coercions that witness type equalities, which turn Core into a particular kind of proof-carrying code. This single addition has opened the door to a range of source-language extensions, such as GADTs and type families. In this talk I'll describe Core, and how it has affected GHC's development over the last two decades, concentrating particularly on recent developments, coercions, evidence, and type families. To test your mettle I hope to end up with the problem we are currently wrestling with: proving consistency of a non-terminating rewrite system with non-left-linear rules. |
Friday
Jul 22, 2011
|
HacPDX II through Portland State University Fourth Avenue Building (FAB) HacPDX-II is an opportunity to join Portland Haskell hackers in building and improving Hackage libraries and tools. The project you hack on can be anything and need-not be pre-existing or general community tools. |
Friday
Sep 25, 2009
|
HacPDX: Portland Haskell Hackathon through Portland State University FAB, Room 86-09 HacPDX is an opportunity to join Portland Haskell hackers in building and improving Hackage libraries and tools. If you've never been, Hackathons are typically not only a good opportunity for experienced devs to work together but also a great way for newcomers to get involved in the community. Visit this website for complete details: http://www.haskell.org/haskellwiki/HacPDX |
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. |
Thursday
Nov 12, 2015
|
Haskell Office Hours – Galois, Inc (from the Meetup description): Welcome to Portland Haskell Office Hours! Bring your projects, or just your excitement for learning. We will still be taking feedback on the format of the meetup, the scheduling, and anything else that will help make this a valuable resource for you. If you are not able to attend, let us know if there's anything we can do to help make it work in the future. -- About Haskell Office Hours: Show up with a project you'd like to share or a problem that you're stuck on, and we'll learn together in small, supportive groups! An "Office Hours" meetup is an opportunity for people of all skill levels to come together, learn, and have fun. Our goal is to focus on inclusion and active participation through teaching and mentorship. The meetup is hosted at Galois, which uses Haskell extensively in industry, and is well-attended by Galwegians who are eager to share their excitement for Haskell and functional programming. This group is very new, so you still have an opportunity to shape how we do things. If the schedule doesn't work for you, or if we can do anything to help you feel more safe and welcome, let us know! |
Wednesday
Sep 27, 2017
|
Haskell User Group – Oregon Technology Buisiness Center (OTBC) All experience levels are welcome, but the group's focus is on intermediate topics. The meeting this evening will be unstructured: we will discuss the direction and goals of the group. |
Friday
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! |
Tuesday
Mar 19, 2013
|
miniKanren Confo – Courtyard by Marriott City Center, Portland The miniKanren Confo is a special 4 hour conference about logic programming (in particular miniKanren). Dan Friedman and Will Byrd (co-authors of the Reasoned Schemer) will provide a keynote. The list of sessions can be found on the Clojure/West site. Registration ($50) is required and can be done either standalone or as part of registration with the Clojure/West conference (Mar 18-20th). |
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. |
Monday
May 15, 2017
|
PDXFunc - Portland Functional Programming Study Group – Collective Agency Downtown We will continue our Haskell lesson series with Lyle delivering Lesson 4 on Higher-Order Programming and Type Inference from Brent Yorgey's CIS194 course. Then Michael Beidler will present on full-stack "isomorphic" web apps with Haskell (REST APIs in servant and GHCJS front-ends with react-flux). The 8th-floor elevator has been restored to operation, so there are no longer stairs to climb. |
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. |
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. |
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. |
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. |
Monday
Sep 9, 2013
|
pdxfunc: Portland Functional Programming Study Group – Janrain Headquarters
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. |
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. |
Monday
Nov 11, 2013
|
pdxfunc: Portland Functional Programming Study Group – Janrain Headquarters Jake Brownson will be presenting on his project River:
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. |
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. |
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. |
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.
Also if there's time, Jim Snow will present on his Glome ray tracer written in Haskell:
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. |
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:
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. |
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. |
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:
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. |
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. |
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. |
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. |
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. |
Sunday
Dec 7, 2014
|
pdxfunc: Portland Functional Programming Study Group – Janrain Headquarters Jake Brownson will be presenting on his project River:
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. |
Monday
Feb 9, 2015
|
pdxfunc: Portland Functional Programming Study Group – Collective Agency Downtown See the mailing list for details on this month's agenda. Attendance is limited at this venue. RSVP via the Meetup group. ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. pdxfunc is a study/user group exploring the world of functional programming, based in Portland, Oregon. The group welcomes programmers interested in all functional languages, including Haskell, Erlang, OCaml, Lisp, Clojure, Scala, Oz, Agda, Idris, and others. The group meets regularly on the second Monday of the month for presentations, demos and discussions applicable to all skill levels, from newbies and experts. |
Monday
Mar 9, 2015
|
pdxfunc: Portland Functional Programming Study Group – Collective Agency Downtown See the mailing list for details on this month's agenda. Attendance is limited at this venue. RSVP via the Meetup group. ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. pdxfunc is a study/user group exploring the world of functional programming, based in Portland, Oregon. The group welcomes programmers interested in all functional languages, including Haskell, Erlang, OCaml, Lisp, Clojure, Scala, Oz, Agda, Idris, and others. The group meets regularly on the second Monday of the month for presentations, demos and discussions applicable to all skill levels, from newbies and experts. |
Monday
Apr 13, 2015
|
pdxfunc: Portland Functional Programming Study Group – Collective Agency Downtown We have some interesting content lined up this month: Robert Dodier, a developer and project administrator on the Maxima project, has offered to give us a talk on it. Maxima is a computer algebra system written in Common Lisp. http://en.wikipedia.org/wiki/Maxima_(software) Also, time permitting, we'll hear about Haskell and Clojure versions of small command-line programs, such as one for parsing and displaying data from a weather API. See the mailing list for details on this month's agenda. Attendance is limited at this venue. RSVP via the Meetup group. ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. pdxfunc is a study/user group exploring the world of functional programming, based in Portland, Oregon. The group welcomes programmers interested in all functional languages, including Haskell, Erlang, OCaml, Lisp, Clojure, Scala, Oz, Agda, Idris, and others. The group meets regularly on the second Monday of the month for presentations, demos and discussions applicable to all skill levels, from newbies and experts. |
Monday
May 11, 2015
|
pdxfunc: Portland Functional Programming Study Group – Collective Agency Downtown Hoping to hear about Haskell and Clojure versions of small command-line programs, such as one for parsing and displaying data from a weather API. See the mailing list for details on this month's agenda. Attendance is limited at this venue. RSVP via the Meetup group. ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. pdxfunc is a study/user group exploring the world of functional programming, based in Portland, Oregon. The group welcomes programmers interested in all functional languages, including Haskell, Erlang, OCaml, Lisp, Clojure, Scala, Oz, Agda, Idris, and others. The group meets regularly on the second Monday of the month for presentations, demos and discussions applicable to all skill levels, from newbies and experts. |
Monday
Jan 12, 2009
|
Portland Functional Programmers Study Group – CubeSpace [ *sniff* out of business 12 June 2009] Julian Blake Kongslie will present an introduction to state-space search, followed by some examples of various search methods in Haskell, with examples of both how to use search and how to write search code. pdxfunc is a study/user group exploring the world of functional programming based in Portland, Oregon. The group welcomes programmers interested in all functional languages, including Haskell, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month. |
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. |
Monday
Nov 13, 2017
|
Portland Functional Programming Study Group - 10th Anniversary Party and New Format Kickoff – Collective Agency Downtown Come celebrate the 10th anniversary of PDX Func! The first meeting was on 11/15/07. There'll be food and drink and cake! We'll also discuss the new format for meetings based on the survey results. We will also go over the Applicative Functor lesson from CIS 193, which will be our final lesson from that track. |
Monday
Dec 12, 2016
|
Portland Functional Programming Study Group - Functional Discussions – Collective Agency Downtown Website |
Monday
Feb 20, 2017
|
Portland Functional Programming Study Group - Haskell Lesson 1 and Data Parallelism – Collective Agency Downtown This is the first month of our new format, based on discussion following the survey: The first half will be geared toward beginners, and the second half will be geared toward more advanced material.
For the next several months the beginner material will be a series of lessons in the Haskell programming language. We will be following Brent Yorgey's CIS 194 syllabus (http://www.seas.upenn.edu/~cis194/spring13/lectures.html). So bring a laptop, or just follow along. Between months you are encouraged to work on the assignments and we will review them. Lyle will be leading the lecture this month. This month's advanced talk will be delivered by Leif, who will be following up his discussion of data parallelism in Spark (Scala) and Haskell. |
Monday
Mar 13, 2017
|
Portland Functional Programming Study Group - Haskell Lesson 2 – Collective Agency Morrison This month, Echo will be leading us through Haskell Lesson 2 (Week 2 at http://www.seas.upenn.edu/~cis194/spring13/lectures.html)! The category theory talk has been rescheduled for April. |
Monday
Apr 10, 2017
|
Portland Functional Programming Study Group - Haskell Lesson 3 and Category Theory – Collective Agency Downtown This meeting continues our Haskell lesson series with Echo delivering Lesson 3 on Recursion Patterns, Polymorphism, and the Prelude from Brent Yorgey's CIS194 course (http://www.seas.upenn.edu/~cis194/spring13/lectures.html).
Lyle will give an introduction to category theory, a theory about mathematical structures and their relationships, which has applications in functional programming. The meeting will be at Collective Agency in the Tiffany Center - the same place as the February meeting. The elevator is expected to be restored to operation by then. (UPDATE: Elevator service to the 8th floor has not yet been restored, so you will have to walk from the 4th floor.) Someone will wait in the lobby to let you in as the front doors are locked after 6. The meeting is on the 8th floor. |
Monday
Jun 19, 2017
|
Portland Functional Programming Study Group - Haskell Lesson 5 and the 1ML Language – Collective Agency Downtown Join us for another fun-filled evening of learning and discussion!
Tonight, Lyle will present Lesson 5 from Brent Yorgey's CIS 194 lectures: http://www.seas.upenn.edu/~cis194/spring13/lectures/05-type-classes.html, as well as reviewing the homework from Lesson 4. Then, Matt Rice will talk about the 1ML language, a variant of ML which unifies the main expression/type language with the language of the module system (signatures, structures and functors). He's also been creating his own language derived from it. |
Monday
Jul 17, 2017
|
Portland Functional Programming Study Group - Haskell Lesson 6 and Free Things – Collective Agency Downtown This month, Leif will present Lesson 6 on Lazy Evaluation from Brent Yorgey's CIS 194 lectures.
Then, Rob Norris will talk about free things. Meeting is on the 8th floor of the Tiffany Center. If you arrive before the meeting starts, there will be someone in the lobby to open the front door for you. If not, there will be a sign posted with a phone number for you to call, and someone will come down to let you in. Take the elevator on the right to the 8th floor, and exit to your right. The sign next to the space says Forge Portland. We meet in the large open area there. |
Monday
Aug 14, 2017
|
Portland Functional Programming Study Group - Haskell Lesson 7 and A* in Elm – Collective Agency Downtown This month, we'll be meeting in a new location! Collective Agency has moved to 511 SW 10th Ave. We'll be meeting in the main area.
Then, Jamon Holmgren will explain his implementation of the A pathfinding algorithm in Elm. A is used in games to calculate the least-cost path for a computer character to move from one spot to another. Elm is a language similar to Haskell (but simpler) that compiles down to JavaScript, used for apps that run in web browsers. |
Monday
Sep 11, 2017
|
Portland Functional Programming Study Group - Haskell Lesson 8 and Vintage BASIC – Collective Agency Downtown Lyle will present Brent Yorgey's CIS 194 Lesson 8 on IO in Haskell.
Then Lyle will present Vintage BASIC, a BASIC interpreter he wrote in Haskell some years ago but has recently revised. |
Monday
Oct 9, 2017
|
Portland Functional Programming Study Group - Haskell Lesson 9 (Functors) and Minima (Elm) – Collective Agency Downtown Echo will present Brent Yorgey's CIS 194 Lesson 9 on functors in Haskell.
Brian Ginsburg will give a short presentation on Minima (https://brianginsburg.com/minima/), a playground for experimenting with minimalist musical patterns, which he wrote in Elm. We will have extra time in this meeting for hands-on learning. You are encouraged to bring a laptop or work together with someone else. You can practice working with functors, hack on Minima, or ask any other questions you might have. |
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. |
Friday
Aug 28, 2015
|
Snowdrift.coop casual meetup / chat – Lucky Labrador Brew Pub Snowdrift.coop is a volunteer-built non-profit community project focused on a new sustainable matching system to coordinate the global community in better funding shareable freely-licensed works. The Snowdrift.coop platform uses the Yesod web framework written in Haskell. Other technologies and relevant work includes basic HTML/CSS/JavaScript and general design, organizing, and other non-technical tasks. This is the second local Portland meetup. While the community includes people on many continents across the globe, we have a strong Portland foundation with one of the co-founders, the lead developer, and several active volunteers and supporters in the area. At this meetup, we'll mostly discuss the project overall status, strategy, any other casual chat, planning, and organizing. We'll also focus on just folks getting to know each other as local Portlanders involved in the project. Complete newcomers or just folks curious about the idea are totally welcome, and no particular experience or skills are needed to get involved. |
Friday
Feb 19, 2016
|
Snowdrift.coop meetup – Lucky Labrador Beer Hall Snowdrift.coop casual chat, hang-out, open to all supporters, volunteers, curious folks, and guests. At this meetup, we'll be visit with new Community Director William "Salt" Hale who is coming down from Seattle. Snowdrift.coop is a non-profit community platform building a new sustainable patronage system for public goods (particularly free/libre/open works). We welcome volunteers in all areas including non-technical general design, organizing, and co-op structure issues. On the technical side, the site uses the Yesod web framework written in Haskell alongside basic HTML/CSS/JavaScript. We have a strong Portland foundation with one of the co-founders, the lead developer, and several active volunteers and supporters in the area. |
Saturday
Dec 5, 2015
|
Snowdrift.coop meetup / chat / hack session – Lucky Labrador Brew Pub Snowdrift.coop is a volunteer-built non-profit community project focused on a new sustainable matching system to coordinate the global community in better funding shareable freely-licensed works. The Snowdrift.coop platform uses the Yesod web framework written in Haskell. Other technologies and relevant work includes basic HTML/CSS/JavaScript and general design, organizing, and other non-technical tasks like co-op structure issues. While the community includes people on many continents across the globe, we have a strong Portland foundation with one of the co-founders, the lead developer, and several active volunteers and supporters in the area. At this meetup, we'll mix casual chat with focusing on some refactoring on the Haskell side and hacking on HTML/CSS stuff for the new design. |
Thursday
Jan 21, 2016
|
Snowdrift.coop meetup / SCALE-send-off – Lucky Labrador Brew Pub Snowdrift.coop is a non-profit community platform building a new sustainable patronage system for public goods (particularly free/libre/open works). The site uses the Yesod web framework written in Haskell alongside basic HTML/CSS/JavaScript. We welcome volunteers in all areas including non-technical general design, organizing, and other tasks like co-op structure issues. We have a strong Portland foundation with one of the co-founders, the lead developer, and several active volunteers and supporters in the area. At this meetup, we'll be meeting long-time volunteer Jason Harrer (aka JazzyEagle) who is in town for a rare business visit. We'll also be celebrating and wishing well to Aaron and Bryan who are heading down to the Southern California Linux Expo to promote Snowdrift.coop this weekend. |
Tuesday
Aug 16, 2011
|
Tech Talk: Back-to-back talks on Haskell and Embedded Systems – Galois, Inc Presented by Sebastian Niller and Nis N. Wegmann 1title: Translation of Functionally Embedded Domain-specific Languages With Static Type Preservation by using Witnesses abstract: Static type preservation automatically guarantees type-correctness of an embedded domain-specific language (eDSL) by tying its type system to that of the host-language. Not only does this obviate the need for a custom type checker, it also preserves type-correctness during code transformations and optimizations, and simplifies and increases the efficiency of interpreters. When implementing a translator from a source DSL with type preservation to a target DSL, the commonly chosen approach requires the incorporation of extensions in the source DSL specific to the target DSL, which, in cases where multiple back-ends are required, obfuscates the source DSL and decreases the overall modularity. We show that by using witnesses, a technique which facilitates the construction of type-level proofs, we can effectively cope with this issue and implement translators without extending the source DSL. We have applied our approach on Copilot, a Haskell-embedded domain specific language for runtime monitoring of hard real-time distributed systems, and used it for implementing two back-ends targeting the Haskell-embedded languages Atom and SBV. Our approach restrains to the Haskell 2010 Standard except for existentially and universally quantified types. 2title: From High-Level Languages to Monitoring Fault-Tolerant Hardware: Case-Studies of Runtime Verification Using Copilot abstract: Failures of hard real-time systems can be caused by systematic faults in software and hardware, as well as by random hardware faults, and faults due to wear out of hardware components. Even if monitoring software is proven to comply to its specification, there is no guarantee that failing underlying hardware does not affect the monitors themselves. An application of distributed Copilot monitors to a redundant airspeed measurement system is presented. We show the use of monitors enables the system to withstand benign and Byzantine hardware and software faults. The second part of the talk presents current work using Copilot to monitor the MAVLink protocol in flight of a sub-scale model of an Edge 540T aircraft. |
Friday
Dec 14, 2018
|
Tech Talk: Teaching Haskell in the Real World – Galois Inc. Abstract: Teaching programming is a hard job. Teaching Haskell is a way harder given its inherent complexity and expectations students have. Nevertheless, there are many approaches to do that. In this talk, I would like to outline the practices that I use and those that I don’t find fruitful. There are quite a few books that can be used for teaching, and I will try to categorize them in terms of their ability to educate a professional Haskell developer. Haskell is a big language, so what should be taught is another crucial question. Should it be a course on functional programming in general or Haskell specifics are fine to teach? For example, there is no clear answer on whether you should attempt teaching something like lenses or stream I/O given limited time. How to teach students about monads? Well, everyone knows the right answer, I will describe my approach. I will also talk about ways to motivate students and to make them learn Haskell by themselves. Speaker: Vitaly Bragilevsky, Senior Lecturer at Southern Federal University Bio: Vitaly Bragilevsky serves as both the Haskell 2020 Language Committee and the GHC Steering Committee member. He works as a Senior Lecturer at the Southern Federal University in Rostov-on-Don, Russia where he teaches undergraduate students functional programming and theory of computations. He is the author of ‘Haskell in Depth’ (Manning Publications, available via Manning’s early access program). Recording: The presentation will be live streamed on our YouTube channel. |