Notes For Haskell Love 2020

Although I did not attend this online event while it was happening, I decided to watch a majority of the videos from the Haskell Love 2020 virtual conference. Then, I broke them down into different categories based on whether I understood the material, and whether I have a particular response. Let’s begin listing them

Talks I watched

Talks That Were Over My Head

Zainab Ali — A Dominion of Domains

I was super interested in this topic, because I am interested in the intersection of game design and programming languages. However, I didn’t absorb the information very well, and I think I’d have to be in the middle of implementing my own system before I would be able to fully appreciate this talk.

Emily Pilmore — Hulk SMASH: re-imaging the Maybe-monad and its design space

The easier of the two Category Theory talks, I’m still not fully cognizant of CT enough to be able to get this one. Which is kinda hilarious, because Emily says at the beginning that this is an easy going talk. Oh well, maybe I’ll return to this talk later if/when I learn more about mathematics.

Richard Eisenberg — Parameters of Many Flavors

So, I was able to more or less follow along with the ideas as the talk happened, but I don’t know enough about Haskell internals and type-level programming to be able to keep all of the info in my head.

Bartosz Milewski — Replacing Functions with Data

I couldn’t even finish this one, I felt like I was in an uncomprehending fog the whole time that I was listening. All this talk did was to make me want to pick up his Category Theory book and actually learn the material all the way through this time.

Talks That Taught Me Something

Jason Shipman — Context Is Everything*

The context library’s interface is somewhat similar to Python’s context manager system. The major difference is that instead of passing an object that has the correct fields, you pass in a well-typed context store type that holds arbitrary data of a single type. I haven’t had occasion to use this library yet, but I would like to try it out sometime.

Gabriel Gonzalez — How to market Haskell to a mainstream audience

This talk was really important to me, because I realized that I held a lot of negative beliefs about what marketing is. I now realize that marketing is a way of optimizing your audience, rather than tricking people. I mean, I realize that marketing is still a tool that can be used for evil, but this perspective reflects the core of what marketing does.

Susan Potter — Thinking in Properties

This talk helped solidify much of my understanding of property-based testing, and how you can apply that same mental model to things outside of testing, which I did not think about until watching the talk.

However, I do have one problem: what properties exist? I think that a better understanding of abstract algebra and other mathy domains would help here.

John Wiegley — Technique for writing debuggable Haskell functions

This talk actually taught me a little Category Theory at the end, which was really rewarding because I actually understood it all. The visuals in this talk were top-notch. Now I have another tool in my toolbox.

Philip Wadler — Propositions as Types

I have actually seen this talk before, and the ending was still just as rewarding. The difference this time was that he had a student animate some of his slides, which made it much easier for me to understand.

Tikhon Jelvis — Reasoning under Uncertainty

I only understood this talk because I have studied a little bit of statistics, enough to understand what a probability distribution is. I think that I might revisit this talk later if I need a refresher, or if I need to work with randomness in Haskell.

Pawel Szulc — Getting Acquainted with Lens

This talk’s first half was really useful to me, especially the tip about the Generic version of Lens. The second half, in which he goes into the internals of the implementation, was just over my head.

Veronika Romashkina & Dmitrii Kovanikov — Stan — Haskell Static Analyzer

This talk was pretty cool! This release must be exciting for them. I will say, as of today, the stan package in nixpkgs is broken, so I can’t immediately integrate it into my Nix-based Haskell projects. A bummer for sure. However, I think that I’ll try out stan on my next project and see what improvements the system can make.

Vladislav Zaqialov — Haskell to Core: Understanding Haskell Features Through Their Desugaring

This talk was the only one about Haskell internals that I understood. Well, mostly understood. I understand that Core is an intermediate language in the GHC pipeline and that you can see how your code will perform and behave in a lower-level language. It helped me understand the next talk in this list.

Adres Löh — Zero-Overhead Abstractions in Haskell using Staging

This talk ALMOST got into the over my head category. It is about Typed-Template Haskell, which is something that I was unaware of until the talk. It talks about techniques for writing high-level code that compiles to really efficient code.

Alejandro Serrano — GraphQL :heart: Haskell

This was actually the first talk that I watched in the list, because I’m a fan of GraphQL. The takeaway from this talk is that Mu supports GraphQL, and they use a lot of different Haskell features to make working with GraphQL schemas really straightforward. I’m definitely going to try this library out sometime in the future.

Simon Peyton Jones — Elastic sheet-defined functions

So, the response for this one almost deserves a blog post of it’s own, because I really want to explore the intersection of this talk and a program called TreeSheets that might have some insights into the problem. I think that will be a separate blog post.

Jeremy Gibbons — How to design co-programs

This talk was by far the most important one for me in this conference, because I learned about How To Design Programs, and that there are algorithms for writing code. This is how Idris probably operates! Then, the talk kept going and introduced co-programs and co-recursion to me, which I may have heard of before but I didn’t actually learn it; until this talk that is.

Talks I skipped (for now)

These talks I’m just gathering into a list. Either the subject matter didn’t interest me in time for the initial publication of this blog post, or I simply ran out of time altogether. I may watch some of these later and update this post.

  • Conal Elliot — Compiling gracefully
  • Jan Christopher Vogt — Writing 2D games using super simple Haskell
  • Tanmai Gopal — Lightning Talk
  • David Feuer — Stacks and queues with amortized logarithmic-time operations
  • Derek Elkins — Quotient Types + Behavioral Reflection = ?
  • Brandon Chinn — aeson-schemas: Safely extract JSON data when data types are too cumbersome
  • Joachim Breitner — The many faces of isOrderedTree
  • Andrew Lelechenko — Bit vectors without compromises
  • Eric Torreborre — Down to the wire
  • Michal Gajda — Agile generation of Cloud API bindings with Haskell
  • Arnaud Spiwack — Data vs Control: a tale of two functors
  • Marcin Rzez’nicki — Building a web library using super hard Haskell
  • Vitaly Bragilevsky — The clear path to Haskell complexities
  • Alexander Granin — Concurrent applications with free monads and STM

Published by sehqlr

I'm a multipotentialite Millenial from St. Louis, MO. My day job is freelance web development and DevOps, but in a previous life, I was an English major. I'm on the STL Tech Slack, GitHub, Keybase, and Twitter, under the @sehqlr handle. (It's pronounced "secular" like the world-view.) I'm also on Mastodon as

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: