2023 event planning

[frasertweedale]

We will use this issue to plan and schedule events for 2023.

Talks

Schedule

• 2023-02-21
  • @endgame - Everything looks like a function these days
• 2023-03-21
  • @flatwhatson - Introduction to Pre-Scheme
• 2023-04-11
  • @bradparker - Scratching an Itch: From Simple Haskell Data Types to a Streaming HTTP Server [abstract]
• 2023-05-16
  • @rellen - The Erlang Ecosystem for Functional Programmers (and everyone else, too) #45
  • @endgame - A data structure design challenge (abstract)
• 2023-06-20
  • @wibily - Functional Turtles in TypeScript [abstract]
  • @frasertweedale - haskell-ci tutorial
• 2023-07-18
  • @flatwhatson - Guix crash course (~30 mins)
  • @endgame - Free Functor and Applicative
  • @frasertweedale - Haskell Security Response Team update
• 2023-08-15
  • @donovancrichton - Towards Palatable Functional Programming with Dependent Type Theories
  • @gwils - topic: FP in industry
• 2023-09-19 -
  • @LightAndLight - topic: FP in Rust
  • @endgame - Compiling to Combinators [abstract]
• 2023-10-10
  • @donovancrichton - Why is so much of FP about types instead of Functions? [abstract]
  • @gwils - FP Basics: Algebraic Data Types and pattern matching [abstract]
• 2023-11-14
  • @flatwhatson - Evaluating the Meta-circular Interpreter
  • @frasertweedale - Basic financial modelling with beginner-level Haskell
• 2023-12-03 (Sunday) - Social event at Bloodhound

Unscheduled proposals

These are concrete talk proposals where we have a willing presenter. Please file separate issues for general topic requests.

• Purebred update (@frasertweedale / @romanofski)
• Representable Functors, rank2 Functors, culminating in rank2 representable functors, a great way to index record fields using a GADT. (@endgame)
• Haskell, Lua, and Fennel (@endgame)

Venues

• BCC Library Brisbane Square (we have bookings through end of year)

[endgame]

I don't have edit access to this issue, but:

• Representable Functors, rank2 Functors, culminating in rank2 representable functors, a great way to index record fields using a GADT.
• Haskell, Lua, and Fennel

[frasertweedale]

@endgame thank you. If these are general topic requests, please file separate issues for them. If you are volunteering to present on these topics, I will update the list. Please clarify which it is :)

[endgame]

These were ones that I'd proposed on IRC at different times.

[frasertweedale]

These were ones that I'd proposed on IRC at different times.

@endgame I'm sorry, I don't recall them. So you are proposing to give presentations on these topics?

P.S. I mistakenly edited your comment above, instead of replying to it. Sorry about that.

[endgame]

Yes, sorry that was unclear.

[frasertweedale]

@bradparker would you be prepared to talk about Maiwar (or another topic if you prefer) for the April meetup, Tuesday 2022-04-11?

[bradparker]

@frasertweedale yep, I'm keen. Will try to lock down some sort an abstract in the next few days. There's a lot I could talk about, want to make sure it's reasonably well focused.

[bradparker]

Alright, I think I'll talk about the core of it. Getting from an idealized Request -> Response to something that handles streaming bodies (Request -> Consumer ByteString m (Response (Pipe ByteString ByteString m ())), these are not the Consumer and Pipe types from pipes, but the names are sure inspired by pipes.) I won't talk about HTTP message syntax or semantics beyond the absolutely necessary, just that there are a sequence of requests per TCP connection; I won't talk about the details of streaming parsing, will touch on stream-splitting and how that led me to the Pipe type (which is a specialized Parser from pipes-parse.) Title and abstract:

Scratching an Itch: From Simple Haskell Data Types to a Streaming HTTP Server

I enjoy making big things out of little things. Here we'll take a simple but impractical model for handling HTTP 1.1 connections and bring it closer to the real world using mostly simple Haskell data types such as tuples and Either. Along the way we'll discuss an approach to streaming in Haskell, predominantly lifted from both the Streaming and Pipes library ecosystems, starting with a list-like abstraction and ending up with a function-like one.

[frasertweedale]

Anyone got any ideas or people who might be up for the May (or later) talk? April is Haskell so a not-Haskell talk for may would be good.

[rellen]

It would be great if someone could do a talk on fancy stuff in TypeScript:

• https://github.com/gcanti/fp-ts
• https://github.com/gcanti/io-ts
• https://github.com/Effect-TS/effect

[donovancrichton]

Sorry @frasertweedale, what is the duration of the talks at BFPG these days?

[frasertweedale]

Sorry @frasertweedale, what is the duration of the talks at BFPG these days?

You can aim for 1h. If you require significantly less or more time, that's OK, just let me know ahead of time your approximate intended duration.

[frasertweedale]

Abstract for @endgame's May session:

I'll be exploring a data structure design problem that's easy to pose, but for which I have yet to find a satisfactory solution. The problem is applicable to any language with Algebraic Data Types (like Elm or Haskell) and I hope we can work together to find a solution.

[frasertweedale]

Abstract for @wibily talk:

Functional Turtles in TypeScript

This is a talk in two parts.

1. We will use the power of higher-kinded types (HKT) in fp-ts to create a stripped down version of the Python program turtle.
2. Introducing functional programming to JS developers. We will discuss a strategy for introducing front-end teams to functional programming via fp-ts.

[wibily]

Slides for Functional Turtles in Typescript talk:
Functional turtles in TS.pptx
Blog post: https://dev.to/derp/parser-ts-4dad

[frasertweedale]

ping @flatwhatson - could I trouble you for an abstract for your guix crash course preso?

[flatwhatson]

Purely Functional Package Management with Guix

Guix is a purely functional package manager and libre operating system
which leverages the power and simplicity of the Scheme programming
language to provide a reliable foundation for software development and
deployment.

This presentation will begin with a high-level discussion on the topics
of package management, bootstrapping, and reproducible software. We'll
explore how a purely functional package manager actually works, why this
approach is useful, and why it's important.

The remainder of the presentation will be an interactive tour and
demonstration of Guix. We'll review some package definitions and
transformations in Scheme, explore the Guix codebase, and study some
real-world uses of Guix as a dependency management solution for software
projects.

[gwils]

FP in Industry

With its heavy use of Scala, REA is Australia's largest commercial user of Functional Programming (as far as George knows). Functional Programming is one of REA Group's Core Engineering Practices alongside TDD and CD. What does this look like in practice? How did this come to be? Where to from here?

In this talk, we will discuss how REA makes FP work across many teams of varying FP skill levels, including contributors from around the world. We'll learn some of the ten year history of FP at REA, including the challenges faced and lessons learnt along the way. We will discuss current state of FP adoption and usage at REA, which has expanded from Scala into TypeScript and beyond, Finally, we will discuss plans for the future of FP at REA.

[frasertweedale]

Abstract for Donovan's talk in October:

Why is so much of FP about Types instead of Functions?

Beginners to functional programming notice that the talks, discussions, and demos quickly move away from talking about functions to talking about types.

Why is this? What makes type systems so special to functional programming? Why do we talk about type classes so much?

This talk will attempt to answer these questions and explain why types are such a fundamental component of functional programming.

[donovancrichton]

Sorry, we can capitalise the T in types please! :)

…

On Mon, 4 Sept 2023 at 13:05, Fraser Tweedale ***@***.***> wrote: Abstract for Donovan's talk in October: Why is so much of FP about types instead of Functions? Beginners to functional programming notice that the talks, discussions, and demos quickly move away from talking about functions to talking about types. Why is this? What makes type systems so special to functional programming? Why do we talk about type classes so much? This talk will attempt to answer these questions and explain why types are such a fundamental component of functional programming. — Reply to this email directly, view it on GitHub <#44 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ABF3UHUARAOC3XGR7RKXSF3XYVAPRANCNFSM6AAAAAAR4DGKY4> . You are receiving this because you were mentioned.Message ID: ***@***.***>

[endgame]

Compiling to Combinators

At ZuriHac this year, Ben Lynn gave a really cool talk about his Haskell-like compiler that compiled to combinatorial logic combinators. This is an older technique, and was a popular research area during the 1970s, but these days other techniques are used (e.g., GHC's Spineless Tagless G-Machine).

It's really grabbed my interest. One advantage of compiling to combinators is that the underlying runtime is much simpler to understand and implement. We'll start in the middle — lambda calculus — and look at how we can compile lambda terms down to combinators. In doing so, we'll see how we get a lot of useful stuff for free, like structure sharing, lazy evaluation, and are freed from worrying about closures and variable scope. Then let's look at how we can interpret combinators in a low-level language, and how we can compile other features of a functional programming language down to lambda terms. This gives us an unbroken chain of transformations from high-level features down to a language runtime.

[frasertweedale]

Ping @LightAndLight - are you still able to present at the September 19 meetup? If so, please provide an abstract ASAP. Thanks!

[LightAndLight]

#44 (comment):

are you still able to present at the September 19 meetup? If so, please provide an abstract ASAP. Thanks!

Sure am, talk is still in progress:

Rust and functional programming

What is Rust? What is functional programming? Can (or should) you do functional programming (whatever that is) in Rust? For the past ~7 years, I've mostly programmed using Haskell. Over the past couple of years I've become increasingly interested in writing very efficient programs, and Rust has become my systems programming language of choice. It feels like a natural choice, given my background, which suggests it's at least "functional programming adjacent". In this talk I explore the meaning of "functional programming" and the extent to which Rust's features support (or undermine) the paradigm.

[donovancrichton]

Are we meeting on the 10th next month? There's nothing on the meetup website, do we have a 2nd speaker?

[frasertweedale]

@donovancrichton I think maybe Jack or I will pull something together. We will decide and announce the meetup in the next couple days.

[donovancrichton]

Just following this up, had some interest from some members of the UQ computing society in coming along next Tuesday, and noticed the meetup was still not updated yet.

[gwils]

FP Basics: Algebraic Data Types and pattern matching

This talk should make sense to anyone who's done programming before and seen a modern language like Swift or Kotlin. No prior FP knowledge required!

Don't let the name scare you; Algebraic Data Types (ADTs) are one of the most powerful, relevant, and easy-to-learn ideas to have come out of the world of functional programming. In this talk, we'll learn what ADTs are, how to work with them, and we'll see them pop up in a few different programming languages, including some that are very popular! ADTs work best when paired with pattern matching, so we'll be looking at that too.

[frasertweedale]

Just following this up, had some interest from some members of the UQ computing society in coming along next Tuesday, and noticed the meetup was still not updated yet.

Sorry for the delay @donovancrichton. Event has been created and announced: https://www.meetup.com/brisbane-functional-programming-group/events/296508399/

[flatwhatson]

Evaluating the Meta-circular Interpreter

A meta-circular interpreter is a program which interprets the language
that it's written in, and can therefore run itself. Far from redundant,
and surprisingly simple, this provides a starting point for the
exploration of fundamental topics in computer science. Beginning with
some history and a crash-course in primordial Lisp, we'll discuss and
implement a variety of functional programming language features.

[frasertweedale]

2023 is over. Closing. See also 2024 planning issue: #48