Noon has a chat with LaToya Anderson, who recently completed a Tweag Fellowship focusing on open-source software for quantum chemistry calculations. Topics of discussion include LaToya's prior education as a dancer, her interests and passions for quantum computing, what interested her in the field, thoughts on how the quantum computing ecosystem should harness their public interest, and how to pursue a career in this space!

Special Guest: LaToya Anderson.

Links:

• LaToya Anderson - Homepage
• LaToya Anderson · GitLab
• chelleorc (L Anderson) (github.com)
• Tweag Fellowship
• Schaum's Outlines
• Simons Foundation
• PySCF
• ASE
• Tai-Danae Bradley - At the Interface of Algebra and Statistics

With the news that Simon is leaving Microsoft Research, and now joining Epic Games, we've taken the opportunity to sit down and do a retrospective of his time at Microsoft Research and the various collaborations that have come about as part of that journey.

Special Guest: Simon Peyton-Jones.

Links:

• An Epic future for SPJ

In this episode Noon is joined by Chris Granade, from Microsoft, who talks about their background, their research path, and what brought them into quantum computing. We discuss Chris' journey to the Q# development team, and the book they have co-authored with Sarah Kaiser. We also cover Chris' vision of the necessary skills to get engaged working in the field, and some pitfalls to watch out for. Tune in for an exploration of a very interesting person and field, and to get some hints as to where functional programming and type theory might play a role in future quantum programming languages!

Special Guest: Chris Granade.

Links:

• Q# Programming Language
• Q# Community
• Robin Blume-Kohout — A list of lectures from Robin available on PIRSA.
• Carl Bender - Mathematical Physics - Sequences - PIRSA — This is the lecture series on convergent and divergent sequences.
• Nielsen & Chuang Textbook on Quantum Computation — A classic now but still, I believe, the bible. Michael Nielsen has since put out some more accessible introductions: https://quantum.country/.
• Alan Geller - Why do we need Q#?
• Learn Quantum Computing with Python and Q# — Book by Sarah Kaiser and Chris Granade.
• Unitary Fund
• Unitary Fund - Discord

Noon and Isaac have a chat about the state of front-end development and Isaac's motivations in bringing a new player to the market: Shpadoinkle, written in Haskell. Isaac discusses some of the issues he has with other approaches and how he and the Shpadoinkle team have been working to resolve them!

Special Guest: Isaac Shapira.

Links:

• shpadoinkle.org
• Platonic Systems
• Miso
• Reflex FRP
• Sketch.systems
• jsaddle
• Asterius
• A city is not a tree by Christopher Alexander

Apostolos Chalkis is a PhD student from the University of Athens. As part of his recent Tweag fellowship, he developed dingo, a Python package to analyze steady states of metabolic networks—networks of biochemical reactions that take place in any living cell—using geometric random walks and other methods from computational geometry.

In this episode, Apostolos explains what metabolic networks are and how he applies Markov Chains Monte Carlo methods to understand them. Also check out Apostolos's blog post, where he shows a particular application of his package to the search for potential COVID-19 treatments.

Special Guest: Apostolos Chalkis.

Links:

• Searching for COVID-19 treatments using metabolic networks
• https://github.com/GeomScale/dingo
• https://github.com/GeomScale/volume_approximation
• https://geomscale.github.io/

Rickard Nilsson is a founder of NixBuild.net, a cloud service that runs your Nix builds. He is a long time Nix user and contributor. His company - Immutable Solutions - helps companies design, develop and deploy server systems and software. Everyday he uses Nix in production.

Special Guest: Rickard Nilsson.

Links:

• NixBuild.net
• The NixBuild.net blog
• NixBuild.net User Survey
• NixBuild.net Twitter

In this episode, Robin Bate Boerop talks to Mathieu Boespflug, the founder and CEO of Tweag. Tweag is a company that specializes in functional programming and was founded in 2013, when this technology was still perceived as a niche tool for early adopters. Since then, Tweag has grown into a mature software consultancy with a wide variety of industry projects, always keeping the core principles of functional programming at heart that promote composability, reproducibility, correctness and many other desirable properties for software.

Mathieu and Robin talk about the founding of Tweag and what Mathieu wanted to work on and bring to the software industry. In particular, we hear about Mathieu's interest in a diversity of programming languages, Tweag's work towards interoperability of languages via build systems, and other interests that inform the R&D that Tweag undertakes. We wrap up with some perspectives on the future of the programming industries and some trends that the industry is working on, and thoughts on interesting areas of programming-language research that are coming to the languages we know and love!

Special Guest: Mathieu Boespflug.

Links:

• Tweag's website
• Tweag's engineering blog

Kicking off the first "Community Chat" session, Noon chats to Melbourne-based Hasura engineer Lyndon Maydwell (aka "sordina") about his journey into functional programming, and a recent blog post where Lyndon advocates for the philosophy of avoiding success at all costs via an incremental process.

Lyndon founded the Melbourne Haskell Meetup in 2013, has organised several workshops around teaching Haskell, is the President of the Melbourne Functional Programming Association and one of the Co-Founders and chief organisers behind the successful Compose :: Melbourne conference. Lyndon presently works at Hasura on the Cloud team.

Special Guest: Lyndon Maydwell.

Links:

• Succeeding While Avoiding Success at All Costs — Blog post about Hasura project run with a "avoid success at all costs" philosophy.
• Hasura — Instant GraphQL APIs.
• ~ Bows and Arrows ~ Composition as Expression — Lyndon's blog.
• Parse, Don't Validate — lexilambda's thoughts on how to think about functional programming.
• Christopher Alexander — An architect famous for promoting an "incremental" building style.
• Compose :: Conference — The overall website for the Compose :: Conference event.
• Melbourne Functional Programming Association Incorporated — Melbourne-based organisation for managing local events related to FP/Haskell.
• Coffin Corner — Don't get trapped here!
• Esolangs
• Adobe Cold Fusion
• D-Wave
• GridLAB-D
• π-Base — Website from which Noon learned how to build a Haskell website, way back in the day!

Domen Kožar is the founder of Cachix, a popular caching service and one of the first products exclusively targeting the Nix ecosystem. He is also behind various community initiatives such as, for example, most recently a open collective fund to improve Nix' MacOS support. In this episode, Rok talks to Domen about how he came to work with Nix, his experiences with it and thoughts on how it evolves.

Special Guest: Domen Kožar.

Links:

• Domen's homepage
• Domen's Cachix - Never build software more than once.
• The Nix dev tutorials
• The Nix MacOS fund on open collective

Three core developers from the Haskell linear types team are on this show: Arnaud Spiwack, Richard Eisenberg and Krzysztof Gogolewski. They have conceived, reviewed and implemented the Haskell linear types extension that is shipped with the latest compiler version. Linear types allow to express that a function uses an argument exactly once in its type signature which opens all kinds of possibilities.

In this episode, Arnaud, Richard and Krzysztof give a short introduction to linear types and then answer community questions that have been asked on reddit. The questions that are answered are outlined below. Links and further material are available on the episode website on compositional.fm/linear-types-ama .

Thank you for contributing the questions and happy listening!

MP3 Chapters:

[00:00:00] Introduction

Questions:

[00 : 12 : 40] Will using linear types throughout my program improve performance?

[00 : 16 : 14] If I see a function with linear type in it's type signature, what kinds of things might it tell me about the purpose or use cases for that function?

[00 : 20 : 51] How might LinearTypes pave the way for an alternative to conduit,pipes, and other streaming IO libraries?

[00 : 23 : 31] Are linear types inferable with the Hindley-Milner algorithm?

[00 : 24 : 54] Are the current boxed linear containers the first step or all that is planned for now?

[00 : 26 : 31] Are nested linear containers possible?

[00 : 30 : 37] There were plans for a safe coerce-style freezing api, does that still seem workable?

[00 : 31 : 44] What is the state of the linear case/let/if/where mechanism?

[00 : 35 : 15] Are there any thoughts about ressource guarantees or RAII types in some far utopian future?

[00 : 41 : 17] How do the Haskell linear types compare to the Rust equivalent?

[00 : 48 : 02] What are the scenarios where the use of linear types makes a lot of sense?

[00 : 51 : 19] Will we get linear functions taking and returning a state token that can effectively replace IO?

[00 : 59 : 10] What benefit will linear types bring to a garbage collected language like Haskell?

[01 : 02 : 13] Is an automatic "C-like" memory management separate from Haskell's garbage collector on the linear types roadmap?

[01 : 02 : 58] Could strictness analysis results be used to suggest extra linear arrows with an optional warning?

[01 : 04 : 04] What are limitations and recommendations concerning migration of existing code?

[01 : 04 : 58] To what extent can a package mix code that uses linear types with code that does not use linear types?

[01 : 07 : 50] What is the recommended practice for migrating existing libraries to use linear types?

Special Guests: Arnaud Spiwack, Krzysztof Gogolewski, and Richard Eisenberg.

Links:

• Call for community questions on reddit
• The original paper that outlined how linear types could be implemented in Haskell
• The linear-types GHC proposal
• All Tweag linear types blog posts
• linear base - a standard library for developing applications with linear types
• [00 : 15 : 30] GHC ticket about using linear types
• [00 : 18 : 40] Parametricity theorems and linear logic
• [00 : 33 : 00] GHC ticket about linear types and rebindable if then else
• [00 : 34 : 00] Workaround for linear case in 9.0
• [00 : 34 : 20] GHC ticket about linear let
• [00 : 46 : 30] Blog post about destination passing style
• [00 : 53 : 20] Critique of the IO Monad explanation 1
• [00 : 53 : 20] Critique of the IO Monad explanation 2