[00:00.000 --> 00:14.520]  All right, so our final talk for the Dev Room today is by David Christensen.
[00:14.520 --> 00:19.800]  He is the Executive Director of the Haskell Foundation and has worked with Haskell and
[00:19.800 --> 00:24.280]  functional programming in both academia and industry.
[00:24.280 --> 00:29.760]  He was a major contributor to the first version of Idris and its Emacs mode, together with
[00:29.760 --> 00:31.400]  Daniel P. Friedman.
[00:31.400 --> 00:37.440]  He wrote The Little Typer, an introduction to dependent type theory, and is currently
[00:37.440 --> 00:43.160]  working on functional programming in Lean and introduction to writing programs in Lean
[00:43.160 --> 00:44.680]  4.
[00:44.680 --> 00:49.880]  His presentation today is Open Source Opportunities with the Haskell Foundation.
[00:49.880 --> 00:50.880]  Thank you, David.
[00:50.880 --> 00:51.880]  Thank you.
[00:51.880 --> 01:03.080]  So, as a brief overview, I'll be presenting three major sort of categories of speech today,
[01:03.080 --> 01:04.080]  I guess.
[01:04.080 --> 01:09.040]  A bit about lore and values of Haskell for those who are new to the community, a bit
[01:09.040 --> 01:13.440]  about institutions and projects that kind of keep us all up and going, and at the very
[01:13.440 --> 01:18.640]  end I will plug my employer, the Haskell Foundation, as one does.
[01:18.640 --> 01:22.160]  So to begin with, lore and values.
[01:22.160 --> 01:25.880]  Many people coming in here who don't know Haskell so well might be thinking, what is
[01:25.880 --> 01:26.880]  Haskell?
[01:26.880 --> 01:27.880]  And I'm not going to answer that at all.
[01:27.880 --> 01:31.480]  I'm going to answer another question, which is, who is Haskell?
[01:31.480 --> 01:35.720]  And the reason why I think this is an interesting question to answer, well, my thinking was
[01:35.720 --> 01:40.640]  really influenced by this essay by Ken Pittman from back in 1994 called Lambda, the Ultimate
[01:40.640 --> 01:47.040]  Political Party, which was kind of a riff on a series of MIT, AI lab memos, Lambda the
[01:47.040 --> 01:53.520]  Ultimate X, where X are things like op code and so forth.
[01:53.520 --> 01:57.120]  And most of this is a bunch of details about the LISP standardization project of the early
[01:57.120 --> 02:01.320]  90s, which is not so relevant anymore to most of us.
[02:01.320 --> 02:06.560]  But for those who are not historians, the author makes a wonderful point where he proposes
[02:06.560 --> 02:10.640]  a thought experiment, and in this thought experiment he says, take the LISP community
[02:10.640 --> 02:14.840]  and give them the C programming language, don't let them talk to C programmers, come
[02:14.840 --> 02:18.560]  back, check in after some time has gone by, and what should you expect to find?
[02:18.560 --> 02:22.120]  Well, you should expect that the version of C that the LISP hackers have been hacking
[02:22.120 --> 02:28.880]  on has grown Lambda, it's grown garbage collection, it's grown fancy interactive environments,
[02:28.880 --> 02:32.640]  it certainly won't run on low end machines anymore, whereas you'd expect that C would
[02:32.640 --> 02:37.520]  be sort of basically like C, but better in the ways that C normally gets better, like
[02:37.520 --> 02:40.000]  maybe Boole has become a type and things like that.
[02:40.000 --> 02:44.800]  This is from the perspective of 1994, that was not the case yet.
[02:44.800 --> 02:48.920]  And what this really says is that the way we should understand a programming language
[02:48.920 --> 02:52.840]  is really as like a shared artifact for a community of practice, like a group of people
[02:52.840 --> 02:56.000]  who are working together on some project.
[02:56.000 --> 03:00.080]  We're not all identical, but we all have something in common which draws us to this programming
[03:00.080 --> 03:05.120]  language, and what this really means is that like the values of a community shape the development
[03:05.120 --> 03:09.920]  of a programming language over time, and the shape of the programming language affects
[03:09.920 --> 03:14.600]  the values of the community, because if you hate it, you're going to leave.
[03:14.600 --> 03:16.720]  So, what are some values of the Haskell community?
[03:16.720 --> 03:21.160]  Well, we think that elegance is a very important thing, very, very important.
[03:21.160 --> 03:24.520]  But we also like to build things that really work, you know, there's a stereotype of Haskellers
[03:24.520 --> 03:27.920]  who, you know, like once they're programmed type checks, they just like delete it because
[03:27.920 --> 03:30.480]  they're done, and that's not true at all.
[03:30.480 --> 03:37.000]  We really do like to build things, you know, like, I used Xmonad for like a decade, but
[03:37.000 --> 03:41.560]  also we really do appreciate a mathematical inspiration, you know, we like to sort of
[03:41.560 --> 03:45.440]  be able to look at a thing and say like, oh, from this branch of mathematics, this means
[03:45.440 --> 03:46.440]  this thing.
[03:46.440 --> 03:51.080]  And a few of us do that, and the rest of us look at those people and say like, yeah.
[03:51.080 --> 03:56.440]  But as opposed to, eh, right, we also really like playing with things, you know, like playing
[03:56.440 --> 04:02.160]  practical jokes in the type system is something that will get you respect rather than discussed
[04:02.160 --> 04:03.560]  in Haskell.
[04:03.560 --> 04:06.600]  We have a real culture of like colluding through a thing, and then cleaning it up and making
[04:06.600 --> 04:10.480]  it elegant and beautiful later, like you're not expected to prove theorems, and then do
[04:10.480 --> 04:13.960]  your work, it's more like find a thing that works and then see if you can prove something
[04:13.960 --> 04:15.720]  cool about it.
[04:15.720 --> 04:20.080]  We tend to be pretty anti-authoritarian and independent people, that makes my job as chief
[04:20.080 --> 04:26.720]  cat herder more kind of like chief mountain lion herder, which is fun, and typically when
[04:26.720 --> 04:31.000]  we want to make a thing that works well, we're going to be using kind of lightweight semi-formal
[04:31.000 --> 04:36.600]  methods like, you know, fancy types or property-based testing, things like that, as opposed to other
[04:36.600 --> 04:40.960]  processes that are used more so in the rest of the world.
[04:40.960 --> 04:45.000]  We like cleverness, you know, if you can come up with a thing that's like fancy and powerful
[04:45.000 --> 04:48.320]  and cool, like people look at that and say, yes.
[04:48.320 --> 04:54.360]  We tend to have low power distance, you know, if you go to a Haskell event and the person
[04:54.360 --> 04:58.160]  with like the gaggle of young Haskellers following them around says something and you
[04:58.160 --> 05:03.200]  talk back to them, you're likely to be met with respect rather than with like rejection
[05:03.200 --> 05:05.920]  for having dared cross the great leader.
[05:05.920 --> 05:12.280]  We like novelty, and we tend to have a lot of respect for knowledge, and we don't want
[05:12.280 --> 05:17.720]  to say like, oh, that's just book learning, and we also tend to be a bit insular.
[05:17.720 --> 05:21.640]  There's a bit of like a not-invented-here thing that happens quite often in Haskell,
[05:21.640 --> 05:26.720]  and also we've sort of mass-imported a lot of random-unix stuff, like, you know, a preference
[05:26.720 --> 05:31.320]  for kind of grody command-line applications.
[05:31.320 --> 05:33.920]  I think some non-values of the community.
[05:33.920 --> 05:40.200]  One is like achieving correctness through formal discipline organizational design.
[05:40.200 --> 05:44.720]  That certainly happens in some organizations, I think more in the corporate world than in
[05:44.720 --> 05:46.880]  the open-source world.
[05:46.880 --> 05:51.920]  But we also tend to not use traditional software engineering practices even when it might be
[05:51.920 --> 05:55.640]  relevant and useful because we just kind of look at that and say, huh.
[05:55.640 --> 06:01.120]  And also, while we value simplicity and beauty in our language, the things outside of the
[06:01.120 --> 06:07.440]  language we often look at and say, yeah, it's okay if that's a bit crunchy.
[06:07.440 --> 06:09.120]  So where is all this coming from?
[06:09.120 --> 06:12.360]  You know, a community has values, but it also has history.
[06:12.360 --> 06:16.560]  Well, back in 1976, two very important things happened.
[06:16.560 --> 06:20.360]  The first was a paper by Dan Friedman and David Wise called, Cons Should Not Evaluate
[06:20.360 --> 06:22.040]  Its Arguments.
[06:22.040 --> 06:28.720]  Cons is the name of the list constructor in old school lists, and today in lists today.
[06:28.720 --> 06:34.680]  Also David Turner made a new version of the St. Andrews static language, which was lazy.
[06:34.680 --> 06:38.760]  And this sort of gave rise to a cottage industry of cool things that are not all in the slide
[06:38.760 --> 06:41.200]  here because there's too many of them.
[06:41.200 --> 06:49.960]  One notable example in 1984 was lazy ML from Schalmers and also of course Miranda in 1985.
[06:49.960 --> 06:56.440]  And as we almost know, Miranda is a trademark of research software limited.
[06:56.440 --> 07:03.880]  And so then a bunch of other languages came out, like Orwell, Alpha, Clean from the folks
[07:03.880 --> 07:06.560]  at Nightmakin, a really great, interesting language with some cool ideas you should look
[07:06.560 --> 07:12.360]  at, Ponder, and then people would think, well, we've got this nice compiler over here.
[07:12.360 --> 07:13.880]  We've got this nice library over here.
[07:13.880 --> 07:18.800]  We can't use the library with the compiler because they're different languages, but there's
[07:18.800 --> 07:20.600]  not anything importantly different about them.
[07:20.600 --> 07:25.320]  It's just that this one came from this university and this one came from this university.
[07:25.320 --> 07:29.800]  And to be clear, this was a very university-led phenomenon, all of this lazy programming in
[07:29.800 --> 07:31.560]  the 80s.
[07:31.560 --> 07:38.400]  And so a committee got together, and in 1987 and through 1990, they started working on
[07:38.400 --> 07:42.720]  the sort of committee language that they would essentially shave off all the things like,
[07:42.720 --> 07:46.600]  this one uses a single colon for the types, this one uses a double colon, this one uses
[07:46.600 --> 07:50.440]  a capital letter for constructors, this one uses a lowercase letter, and shave off those
[07:50.440 --> 07:55.240]  differences and make this language where you could use a library from the one site on the
[07:55.240 --> 07:57.400]  compiler from the other site.
[07:57.400 --> 08:01.400]  And unfortunately, when you get research, fortunately or unfortunately, when you get
[08:01.400 --> 08:04.840]  researchers in a room together, they tend to do research, and all of a sudden they figure
[08:04.840 --> 08:10.120]  out type classes and they start to do an I.O. with monads, and then Haskell was born.
[08:10.120 --> 08:12.840]  And the, yeah, yay!
[08:12.840 --> 08:17.920]  So the 1990s was like a period of furious hacking both on the definition and the implementation.
[08:17.920 --> 08:19.960]  The two kind of went hand in hand.
[08:19.960 --> 08:23.000]  There were lots of implementations with Haskell in the start, you know, because the idea was
[08:23.000 --> 08:28.440]  that it would be a common standard for implementations, sort of like, in this sense, more like C or
[08:28.440 --> 08:34.560]  common Lisp, and less like, you know, Python or Perl or Rust, which are sort of defined
[08:34.560 --> 08:37.520]  by their canonical implementation.
[08:37.520 --> 08:44.720]  You know, in 1992, work was started on GHC, in 1995 on hugs, has anyone in here used
[08:44.720 --> 08:45.720]  hugs?
[08:45.720 --> 08:52.000]  Ah, good, some hands, yeah, so back in the day, GHC didn't really, didn't have a REPL,
[08:52.000 --> 08:55.680]  so you'd use hugs for the nice interactive environment and the error messages, and then
[08:55.680 --> 09:00.040]  you'd use GHC to compile your code, kind of like standard ML programmers do with like
[09:00.040 --> 09:03.200]  SML and J and Milton.
[09:03.200 --> 09:08.160]  You know, and by the end of the 90s, we had the Haskell 98 report put together by the
[09:08.160 --> 09:13.840]  committee, and by 2001, GHCI came out, and I see this as kind of a watershed moment,
[09:13.840 --> 09:18.840]  because it's when GHC began starting to kind of serve all of the needs of the Haskell community
[09:18.840 --> 09:22.560]  rather than just the batch compiler to make your fast code need.
[09:22.560 --> 09:28.680]  You know, in the 2000s, we had a fairly finished language standard, right, the Haskell committee
[09:28.680 --> 09:35.680]  disbanded itself after Haskell 98 came out in 1999, and a while of work was put into
[09:35.680 --> 09:39.520]  making Haskell go fast, like let's make the compiler generate better code, let's look
[09:39.520 --> 09:44.840]  at all these nice optimizations we can do, also at doing like reliable concurrent programming,
[09:44.840 --> 09:49.440]  so we got a lot of cool like parallel Haskell features, we got software transactional memory,
[09:49.440 --> 09:55.120]  all this like space age technology stuff from the perspective of the mid-00s at least.
[09:55.120 --> 10:03.160]  And in the 2010s, you know, as I should say, in 2009, we got the Haskell 2010 report, and
[10:03.160 --> 10:07.080]  that was actually the last major revision to Haskell, and there isn't really a committee
[10:07.080 --> 10:11.960]  around it anymore that feels like they can define a new Haskell language, and in some
[10:11.960 --> 10:17.200]  sense, this report was a little bit anachronistic, because by this point, GHC was the Haskell
[10:17.200 --> 10:18.920]  implementation that everyone was using.
[10:18.920 --> 10:24.240]  Through the 2010s, GHC was extended with all sorts of super fancy types.
[10:24.240 --> 10:29.080]  You've seen a little bit of them today, but there was this whole line of research of how
[10:29.080 --> 10:34.320]  can we extend the expressive power of the type system while still keeping a lot of the properties
[10:34.320 --> 10:37.840]  we like of Haskell, like being able to write down a simple program and have it tell me
[10:37.840 --> 10:41.480]  what the type should be, as opposed to having me tell it what the type is first, and then
[10:41.480 --> 10:43.920]  having it check the program.
[10:43.920 --> 10:48.040]  And it's, you know, we're only a little bit into the 2020s, but I think that what's happening
[10:48.040 --> 10:53.680]  here is that we're going to finally deliver on our potential of having the best experience
[10:53.680 --> 10:58.280]  driven by the fancy types and the fearless concurrency and all these things, but we'll
[10:58.280 --> 11:00.360]  see what happens.
[11:00.360 --> 11:02.280]  So a little bit about institutions.
[11:02.280 --> 11:07.320]  I've been talking a lot about sort of community and history, but a community is more than
[11:07.320 --> 11:12.000]  just a group of people, there's also, you know, figures within any community who kind
[11:12.000 --> 11:18.040]  of set the agenda for that community, who others look to for leadership and inspiration
[11:18.040 --> 11:20.400]  from time to time.
[11:20.400 --> 11:24.840]  And an interesting thing about Haskell, this comes up a lot in various discussion boards,
[11:24.840 --> 11:29.760]  is people will say, what is the Haskell X, right, where X is drawn from the set containing
[11:29.760 --> 11:36.040]  build tool or tutorial or book or IDE or compiler or whatever.
[11:36.040 --> 11:43.000]  And in fact, we can't answer that question because unlike something like, you know, Python
[11:43.000 --> 11:48.920]  or Rust or many other of these implementation defined languages, there isn't really any
[11:48.920 --> 11:54.320]  organization that owns Haskell and can say, we're going to now say that this is the official
[11:54.320 --> 11:56.320]  Haskell X.
[11:56.320 --> 12:02.760]  And, you know, like, we're essentially defined by GHC, but it doesn't have, the GHC project
[12:02.760 --> 12:07.640]  doesn't have this kind of leading role in the same way that, like, the Python project
[12:07.640 --> 12:09.520]  has in Python.
[12:09.520 --> 12:15.400]  So that's, we do have various committees that are, you know, that exist and people mostly
[12:15.400 --> 12:18.360]  do what they say.
[12:18.360 --> 12:22.280]  And like I said, we're a fiercely independent bunch of people.
[12:22.280 --> 12:27.160]  So there's the Core Libraries Committee and they're the ones who are maintaining and controlling
[12:27.160 --> 12:33.720]  the standard libraries, so things like strings and lists and all the basic stuff that you
[12:33.720 --> 12:37.560]  need that essentially every Haskell program is going to need either directly or transitively
[12:37.560 --> 12:39.720]  through other things.
[12:39.720 --> 12:45.600]  Then we have the GHC Steering Committee and the name of that committee is a bit misleading.
[12:45.600 --> 12:50.960]  In fact, what they do is they evaluate changes to the language implemented by GHC.
[12:50.960 --> 12:55.520]  So in some ways, this is the forum in which changes to Haskell are discussed and if you
[12:55.520 --> 12:59.320]  have input about it, that's where you should show up.
[12:59.320 --> 13:04.280]  Also if you'd like to participate, you know, they regularly have new nominations, so it's
[13:04.280 --> 13:06.440]  a place that you can do that.
[13:06.440 --> 13:11.000]  And then we have the Haskell Org Committee, which is responsible for administering the
[13:11.000 --> 13:16.080]  Haskell.org site and that's both the website but also, like, the sub-domain namespace.
[13:16.080 --> 13:19.880]  So when I needed to get errors at Haskell.org for a thing, they're the ones that I went
[13:19.880 --> 13:21.280]  to and asked.
[13:21.280 --> 13:25.200]  And they also, for historical reasons, run the Google Summer of Code or Haskell Summer
[13:25.200 --> 13:28.320]  of Code when there is no GSOC.
[13:28.320 --> 13:33.360]  The key tools in Haskell, as we've seen earlier, there's the major compiler, GHC.
[13:33.360 --> 13:40.040]  We've got HLS, which gives us all those fancy features that we saw earlier in the talk.
[13:40.040 --> 13:44.120]  There's Cabal and Stack are the two major build tools.
[13:44.120 --> 13:47.640]  There's GHCUP, which is like a tool chain installation and management program, which
[13:47.640 --> 13:49.840]  is quite convenient to use.
[13:49.840 --> 13:55.840]  There's Hackage, which is kind of our C-Pen or C-10 or crates.io or depending on where
[13:55.840 --> 14:00.680]  you come from, one of those might make sense to you, which is a centralized repository
[14:00.680 --> 14:01.680]  of packages.
[14:01.680 --> 14:04.080]  Luckily, we've just got one of those.
[14:04.080 --> 14:09.160]  Stackage is a version-pinned distribution of packages from Hackage that have been tested
[14:09.160 --> 14:12.760]  to work well together, so you can get a coherent set of stuff.
[14:12.760 --> 14:17.120]  These days, like in the old days, as the name suggests, Stackage used to work with Stack.
[14:17.120 --> 14:21.280]  Now you can also point Cabal at it as well, if you want.
[14:21.280 --> 14:24.600]  Then there's Haddock, which is a documentation generator, and it's in need of some serious
[14:24.600 --> 14:25.600]  refactoring.
[14:25.600 --> 14:29.320]  The maintainer is sitting over here, so if that's something you'd like to get involved
[14:29.320 --> 14:33.120]  with, you should go talk to them, because that could be a really useful way to help
[14:33.120 --> 14:34.120]  out.
[14:34.120 --> 14:38.440]  Also, GHCUP, I know, is looking for a co-maintainer to share some of the burden there, so that's
[14:38.440 --> 14:45.240]  another good place to get involved, where you don't have to be a super-type system expert.
[14:45.240 --> 14:48.640]  Last meeting's Haskell Playground is looking for volunteers as well.
[14:48.640 --> 14:53.920]  This is a sort of up-and-coming project to have sort of online place where you can go
[14:53.920 --> 14:57.320]  put in some Haskell code and run it and see what happens, without having to install anything
[14:57.320 --> 14:58.880]  on your machine or anything like that.
[14:58.880 --> 15:05.160]  You can think of it as, essentially, like an active paste bin.
[15:05.160 --> 15:08.800]  I've been instructed to tell you to look at the help-wanted and good first-issue labels
[15:08.800 --> 15:13.560]  on the issue tracker, and mentorship is available from the author.
[15:13.560 --> 15:19.000]  The Haskell Foundation is the other institution that I didn't talk about with the first ones.
[15:19.000 --> 15:24.520]  We're a very, very new non-profit, just a couple years old, and we are trying to broaden
[15:24.520 --> 15:28.000]  the adoption of Haskell because a programming language is more useful when more people use
[15:28.000 --> 15:31.520]  it, so the more people we can get making cool Haskell stuff, the better it gets for all
[15:31.520 --> 15:32.680]  the rest of us.
[15:32.680 --> 15:36.680]  Also, we think that there's a lot of really good things in Haskell that haven't, like
[15:36.680 --> 15:39.840]  good ideas, that haven't spread as far as they could yet.
[15:39.840 --> 15:43.540]  The rest of the world definitely deals with first-class functions now, so we've succeeded
[15:43.540 --> 15:44.540]  there.
[15:44.540 --> 15:49.040]  The rest of the world is basically catching on about monads, so we're succeeding there,
[15:49.040 --> 15:53.600]  but there's a lot of other cool stuff that I think we still have that if we want to make
[15:53.600 --> 15:59.960]  the world a better place, we can spread those good ideas.
[15:59.960 --> 16:03.480]  The point of the Haskell Foundation is not to come in and take over everything.
[16:03.480 --> 16:08.960]  Our goal is really to support existing processes from our fiercely independent Haskell community
[16:08.960 --> 16:14.080]  and figure out what opportunities to help out.
[16:14.080 --> 16:20.840]  I am the executive team, so I've been in that role since May of 2022, so I'm still fairly
[16:20.840 --> 16:21.840]  new at it.
[16:21.840 --> 16:24.160]  I used to work at Gelwa and Deon Digital.
[16:24.160 --> 16:28.440]  Before that, I have a PhD from IT University of Copenhagen from 2015.
[16:28.440 --> 16:31.960]  I also did a postdoc in Indiana University.
[16:31.960 --> 16:36.200]  I worked on interest one, and I helped write the little typer, and I'm working on functional
[16:36.200 --> 16:37.200]  programming in Lean.
[16:37.200 --> 16:40.880]  As you can see, I'm into dependent type stuff, but that's really not the focus of where I'm
[16:40.880 --> 16:42.120]  working in Haskell.
[16:42.120 --> 16:47.520]  I think dependent types are cool, but there's way more cool things than just that.
[16:47.520 --> 16:51.080]  The other full-time person we have at the Haskell Foundation is Brian Richter, who you
[16:51.080 --> 16:52.560]  may know online as Shriekat.
[16:52.560 --> 16:54.960]  I'm actually not sure how to pronounce that.
[16:54.960 --> 17:01.720]  CHR is a consonant cluster found in my own name, but nonetheless unusual in English.
[17:01.720 --> 17:07.840]  He's doing full-time DevOps and CI work for the GHC project and helping to unstick things
[17:07.840 --> 17:13.680]  there and make it easier for both the existing team and new contributors to work on it.
[17:13.680 --> 17:18.560]  He's also looking for volunteers to help out, so if you have knowledge of CI and DevOps
[17:18.560 --> 17:24.640]  things generally, and in particular GitLab, Nix, Python, Bash, and or PowerShell, get
[17:24.640 --> 17:31.240]  in touch with him and he'll put you to work doing useful, interesting stuff for GHC.
[17:31.240 --> 17:35.640]  Another project of the Haskell Foundation is the Haskell error index.
[17:35.640 --> 17:40.040]  This is a new website, which you can get at errors.haskell.org.
[17:40.040 --> 17:43.400]  It really got its start at Xerahack last summer.
[17:43.400 --> 17:47.520]  The way this works is that participating Haskell development tools, and so far there's three,
[17:47.520 --> 17:53.440]  that's GHC stack and GHC up, can assign a unique code to each of the error messages
[17:53.440 --> 17:58.800]  and warnings, and then these can be looked up on this website.
[17:58.800 --> 18:05.200]  The website contains, for a given error message, detailed description of it that's sort of
[18:05.200 --> 18:08.040]  longer than you could put in the error text itself.
[18:08.040 --> 18:13.800]  It can contain any number of examples, so ideally we're going to be providing sort of
[18:13.800 --> 18:17.560]  a before and after example, like a program that exhibits the error message and then one
[18:17.560 --> 18:22.520]  in which it has been fixed, along with details about why that program exhibits the error
[18:22.520 --> 18:25.960]  message.
[18:25.960 --> 18:30.240]  I could really use some volunteer help on this one, so if you're good at CSS and JavaScript,
[18:30.240 --> 18:37.520]  then dark mode support would be super useful, and also we put some work into the CSS, but
[18:37.520 --> 18:41.800]  it could use more, like it's not the most beautiful of websites yet.
[18:41.800 --> 18:44.280]  Also writing documentation content is super useful.
[18:44.280 --> 18:48.200]  If you know enough Haskell to understand one error message and you can write a markdown
[18:48.200 --> 18:52.280]  file and use git, then you have the skills necessary to contribute documentation for
[18:52.280 --> 18:53.800]  one error.
[18:53.800 --> 18:55.440]  So far we have 72 in there.
[18:55.440 --> 19:00.480]  I hope that with the new GHC release coming out that supports the error codes, we'll quickly
[19:00.480 --> 19:09.960]  get the 371 remaining errors documented, no, 271.
[19:09.960 --> 19:14.720]  And also, if the site backend is a static site generator written in Haskell using the
[19:14.720 --> 19:19.880]  HACA library, and right now the deployment script takes too long to run, and if you can
[19:19.880 --> 19:22.480]  help me with the caching to fix that, that would be awesome, because I'm terrible at
[19:22.480 --> 19:25.040]  that stuff.
[19:25.040 --> 19:29.640]  As you saw earlier, Frasier is running our security advisory database.
[19:29.640 --> 19:36.200]  This is a new project, a new initiative, sort of inspired by the Rust and NPM advisory databases.
[19:36.200 --> 19:42.320]  The idea is that it's going to serve as a data source for tools like Cabalstack and Dependabot.
[19:42.320 --> 19:46.440]  And in particular, a lot of organizations that want to use Haskell need to pass ISO
[19:46.440 --> 19:52.440]  2701 certification, and doing that is certainly possible without one of these automated scanners,
[19:52.440 --> 19:55.440]  but then you have to have a conversation with the auditor, and that makes things slower
[19:55.440 --> 19:57.160]  and riskier and more expensive.
[19:57.160 --> 20:00.560]  So if you can just check the box, that's much better.
[20:00.560 --> 20:04.240]  Also there's real value in finding out whether or not one of your dependencies has some sort
[20:04.240 --> 20:07.080]  of a known issue.
[20:07.080 --> 20:11.440]  Volunteers are wanted for the security response team, which is going to be administering the
[20:11.440 --> 20:15.040]  actual contents of the database, but also for tool development.
[20:15.040 --> 20:18.520]  It would be great to be able to sit down and say, you know, Cabal audit or Stack audit
[20:18.520 --> 20:23.920]  and have it spit out a list of things to look out for, and also some public communication
[20:23.920 --> 20:25.920]  help could be useful.
[20:25.920 --> 20:31.520]  Right now we have like a data format for the database, but generating a nice website that
[20:31.520 --> 20:37.720]  documents everything in the searchable would also be a really useful contribution.
[20:37.720 --> 20:41.720]  We have a podcast, the Haskell Interlude podcast, which is looking for guests, members
[20:41.720 --> 20:43.200]  of the Haskell community.
[20:43.200 --> 20:47.280]  So if you'd like to get on there and have a discussion with some leading Haskellers
[20:47.280 --> 20:50.040]  about what you're up to, that would be really cool.
[20:50.040 --> 20:53.320]  Email podcast at Haskell.foundation.
[20:53.320 --> 21:02.200]  The Haskell Optimization Handbook is an in-progress text on how to make Haskell code go fast.
[21:02.200 --> 21:05.560]  I blurred out the address on there a little bit just because it's in the process of moving
[21:05.560 --> 21:07.480]  from one address to another one.
[21:07.480 --> 21:10.360]  But if you Google it, it'll come right up.
[21:10.360 --> 21:14.560]  This is being organized by Jeff Young who works at IOG.
[21:14.560 --> 21:18.160]  He's known as Do You Can Do on the Internet, so you can get a hold of him if you'd like
[21:18.160 --> 21:23.840]  to find ways to contribute text or infrastructure to this project.
[21:23.840 --> 21:27.840]  In addition to all of these sort of concrete technical things, we're also orchestrating
[21:27.840 --> 21:30.160]  the Hackage Security Signing Process.
[21:30.160 --> 21:35.200]  So Hackage uses an instance of the Update Framework, which is a sort of standard way
[21:35.200 --> 21:42.240]  of securing software repositories against man-in-the-middle attacks and untrusted mirrors and these kinds
[21:42.240 --> 21:44.160]  of things.
[21:44.160 --> 21:50.040]  And part of this process is that we have a collection of trustees who have keys, and
[21:50.040 --> 21:54.720]  any three of them have to sign the metadata file from time to time just to keep the thing
[21:54.720 --> 21:55.720]  going.
[21:55.720 --> 22:00.880]  And they're certifying that all of the associated roles are correct.
[22:00.880 --> 22:03.360]  And that's been a volunteer-led process in the past.
[22:03.360 --> 22:06.720]  And we've had a couple of times where we thought, uh-oh, we've got to sign this real
[22:06.720 --> 22:08.680]  fast, otherwise things are going down.
[22:08.680 --> 22:14.000]  And so the HF is, by being a professional organization, we can put a thing in the calendar
[22:14.000 --> 22:18.920]  and get the process going in plenty of time and all of those things.
[22:18.920 --> 22:23.040]  Also, we're going to be doing a sort of lottery factor audit of key projects in infrastructure
[22:23.040 --> 22:27.720]  soon and try to find more places where we need to recruit extra maintainers for important
[22:27.720 --> 22:29.640]  projects and that kind of thing.
[22:29.640 --> 22:33.120]  Some people call the lottery factor a bus factor, but I'd rather think in terms of how
[22:33.120 --> 22:36.600]  many people can win the lottery and retire from computing forever without the project
[22:36.600 --> 22:37.600]  collapsing.
[22:37.600 --> 22:40.200]  It seems a little happier.
[22:40.200 --> 22:43.400]  We've also spent some time helping out the GHC developers.
[22:43.400 --> 22:48.120]  The results of this end up on discourse.haskell.org, typically.
[22:48.120 --> 22:53.640]  Recently they asked us for some help in going out and surveying a certain number of GHC
[22:53.640 --> 22:57.600]  users about priorities for the next six, nine months.
[22:57.600 --> 23:02.280]  And then we collected feedback on that and then developed a report where they said what
[23:02.280 --> 23:04.680]  they're actually going to do based on the feedback.
[23:04.680 --> 23:07.120]  So this is available to be read.
[23:07.120 --> 23:11.360]  And right now we're trying to do something similar for a project on making nightly releases
[23:11.360 --> 23:12.680]  easier to get to.
[23:12.680 --> 23:16.480]  So right now you can get nightlies if you know the incantation, but we'd really like
[23:16.480 --> 23:19.240]  it to be super easy to get a hold of them.
[23:19.240 --> 23:24.120]  And so if you go find, if you think that you could use nightly releases for something,
[23:24.120 --> 23:28.760]  then please go find the discourse thread and post because that way we make sure that whatever
[23:28.760 --> 23:31.880]  solution we have incorporates your use cases as well.
[23:31.880 --> 23:36.920]  And I've already discovered a few that I hadn't thought of, so that's been a useful process.
[23:36.920 --> 23:40.120]  We're organizing a workshop for new GHC contributors.
[23:40.120 --> 23:44.360]  So if you'd like to get started on hacking GHC, but don't yet know how, then you should
[23:44.360 --> 23:51.040]  come to, then you should come to zero hack three days before zero hack and get an introduction.
[23:51.040 --> 23:52.520]  This is still an in progress thing.
[23:52.520 --> 23:54.600]  We don't have a specific speaker list yet.
[23:54.600 --> 23:59.760]  Simon's definitely talking, but the rest is depending a little bit on a survey that's
[23:59.760 --> 24:00.760]  out there.
[24:00.760 --> 24:03.560]  So if you fill out the survey and say what you're most interested in learning to hack
[24:03.560 --> 24:08.920]  on, that'll affect the people who we invite to come and present parts of GHC for potential
[24:08.920 --> 24:11.280]  contributors.
[24:11.280 --> 24:15.560]  And also if you know how to run a hybrid event well, get a hold of me, I don't.
[24:15.560 --> 24:20.320]  I'm going to do my best, but if you could spare 45 minutes on the phone with me to tell
[24:20.320 --> 24:23.120]  me all the things I'm about to do wrong, that would be very valuable.
[24:23.120 --> 24:25.920]  So email me if that's a thing.
[24:25.920 --> 24:27.840]  We have two big working groups at the moment.
[24:27.840 --> 24:35.520]  We have a technical working group which evaluates various project proposals and especially proposals
[24:35.520 --> 24:41.000]  where Haskell Foundation like administrative time or money would be useful.
[24:41.000 --> 24:45.000]  And so if you have something like that, please come and give us a proposal and we'll discuss
[24:45.000 --> 24:50.600]  it and try to refine it and eventually hopefully fund it or administer it or otherwise carry
[24:50.600 --> 24:51.600]  it out.
[24:51.600 --> 24:57.000]  We've also used this to host like a community RFC process in cases where that's needed because
[24:57.000 --> 24:59.640]  as I said earlier, there isn't really anyone who owns Haskell.
[24:59.640 --> 25:03.640]  So it seems as good a forum as any to have some of those discussions.
[25:03.640 --> 25:08.640]  And we have a stability working group which meets every two weeks and we're looking at
[25:08.640 --> 25:14.400]  which involves GHC developers and academics and others and we're trying to find ways to
[25:14.400 --> 25:21.560]  reduce the difficulty posed by updates to the Haskell ecosystem.
[25:21.560 --> 25:26.160]  And that's going to be some combination of social and technical means over time, lots
[25:26.160 --> 25:28.640]  of small stuff.
[25:28.640 --> 25:30.600]  Thank you for listening.
[25:30.600 --> 25:34.360]  If you want to get a hold of me, I'm David at Haskell.Foundation or I'm Christensen
[25:34.360 --> 25:36.120]  on Matrix.org.
[25:36.120 --> 25:39.400]  And then the Haskell Foundation itself is Haskell.Foundation.
[25:39.400 --> 25:43.120]  You can also look at Haskell.org to find out more about Haskell itself.
[25:43.120 --> 25:48.120]  We have, we're on Mass on Twitter as well and the names are up there.
[25:48.120 --> 25:53.280]  And I believe a few minutes, five minutes left so if there's any questions.
[25:53.280 --> 26:14.360]  Thank you, that was a great talk.
[26:14.360 --> 26:20.720]  So I observe like what Haskell Foundation does and there's like a lot of great initiatives
[26:20.720 --> 26:22.680]  and I think it pushed the language forward.
[26:22.680 --> 26:29.960]  But I'm wondering, so does Haskell Foundation measure somehow how popular Haskell is?
[26:29.960 --> 26:33.520]  Every other month there is like a thread that Haskell is dying.
[26:33.520 --> 26:40.960]  So I was just wondering like, do you have some like a concrete data that would say otherwise?
[26:40.960 --> 26:46.400]  Like that, I don't know, like a job postings are growing or the number of companies that
[26:46.400 --> 26:50.400]  using Haskell are growing or like the community is growing somehow.
[26:50.400 --> 26:55.440]  Like do you gather some data like this?
[26:55.440 --> 26:56.440]  Not particularly, no.
[26:56.440 --> 27:04.080]  I haven't found a good way to do it that I think is going to be more signal than noise.
[27:04.080 --> 27:05.560]  I don't think Haskell is dying.
[27:05.560 --> 27:10.480]  I think that there's a couple of people who feel that way and they're entitled to that
[27:10.480 --> 27:13.280]  feeling and they say it regularly.
[27:13.280 --> 27:16.280]  But I don't think that that's a commonly held feeling is my impression.
[27:16.280 --> 27:20.160]  I get the impression that's more a feeling that a couple of people have.
[27:20.160 --> 27:24.960]  I know that I keep hearing about new users of Haskell who I'd never expected because
[27:24.960 --> 27:28.080]  they're not very public about it.
[27:28.080 --> 27:30.240]  Hackage continues to grow.
[27:30.240 --> 27:34.000]  I see job posts on a regular basis which I didn't see a couple of years ago.
[27:34.000 --> 27:41.920]  So those are all anecdotal qualitative things.
[27:41.920 --> 27:48.880]  If you have ideas about non-misleading measurements that are cheap enough that I can do them being
[27:48.880 --> 27:54.600]  essentially one person with a, you know, not tiny but not infinite budget then.
[27:54.600 --> 27:55.600]  Yeah, definitely.
[27:55.600 --> 27:56.600]  I'm not saying it's easy.
[27:56.600 --> 28:01.520]  I was just wondering if you maybe do a self-light.
[28:01.520 --> 28:04.600]  As you know from my background, as you could see from my background, like it's very much
[28:04.600 --> 28:09.520]  on the like programming language side rather than the market research side.
[28:09.520 --> 28:12.720]  So if you do have good resources, I'd love to hear them.
[28:12.720 --> 28:13.720]  Sure.
[28:13.720 --> 28:20.720]  Thanks.
[28:20.720 --> 28:21.720]  Okay.
[28:21.720 --> 28:26.120]  Any more questions?
[28:26.120 --> 28:27.120]  It seems not.
[28:27.120 --> 28:28.120]  So thank you very much, David.
[28:28.120 --> 28:29.120]  Thanks.
[28:29.120 --> 28:46.200]  Thank you.