Open-Source Opportunities with the Haskell Foundation
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 542 | |
| Author | ||
| License | CC Attribution 2.0 Belgium: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/61529 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
00:00
Lambda calculusWordShape (magazine)Independence (probability theory)System programmingFormal grammarSoftware engineeringExplosionImplementationSurface of revolutionConcurrency (computer science)Type theoryRandomizationComputer programmingQuicksortMassStapeldateiMoment (mathematics)CodeFormal languageSelf-organizationUniverse (mathematics)Cartesian coordinate systemFunctional programmingRevision controlElectronic mailing listParameter (computer programming)Open sourceOpcodeProgramming languageProjective planeLibrary (computing)Point (geometry)BitConstructor (object-oriented programming)Slide ruleType theoryError messageAsynchronous Transfer ModeSocial classSoftware developerShape (magazine)Monad (category theory)Category of beingIntegrated development environmentDifferent (Kate Ryan album)Perspective (visual)Power (physics)Event horizonImplementationProcess (computing)Hacker (term)Formal grammarPresentation of a groupWeightFrequencySeries (mathematics)CompilerSpeech synthesisStandard deviationWebsiteFluid staticsComputer programmingGroup actionSystem programmingAuthorizationSoftware engineeringProgrammer (hardware)Branch (computer science)TheoremDistanceComputer-assisted translationMultiplication signMultilaterationExpected valueTraffic reportingVirtual machineSystem callSpeicherbereinigungSpecial unitary groupMathematicsWhiteboardProof theoryRepetitionView (database)Forcing (mathematics)Software testingTheorySoftwareVideo gameComputer animation
09:34
Concurrency (computer science)Surface of revolutionType theoryExplosionIntegrated development environmentDistribution (mathematics)Revision controlCompilerChainData managementServer (computing)Repository (publishing)Code refactoringSelf-organizationProcess (computing)Copenhagen interpretationDigital signalComputer programmingFunctional programmingService (economics)Formal grammarPower (physics)Gastropod shellPrice indexError messageDigital object identifierJava appletCross-site scriptingScripting languageFront and back endsContent (media)WebsiteComputer programmingGroup actionMultiplication signFigurate numberUniverse (mathematics)Goodness of fitPoint (geometry)ArmProcess (computing)Type theoryFocus (optics)Programming languageMathematical optimizationQuicksortCompilerError messageFunctional programmingProjective planeCodeMessage passingWebsiteCopenhagen interpretationSubject indexingDescriptive statisticsPower (physics)AreaDigitizingTouch typingSystem programmingImplementationCategory of beingLine (geometry)Computer programmingBitTraffic reportingOnline helpInheritance (object-oriented programming)Content (media)NumberService (economics)Software developerBuildingFormal languageLibrary (computing)Self-organizationCore dumpVector potentialComputer fileNamespaceMathematicsInternet forumoutputString (computer science)Boolean algebra1 (number)Centralizer and normalizerMedical imagingSet (mathematics)AdditionNominal numberSpacetimePerspective (visual)Googol10 (number)Semiconductor memoryVirtual machineDivisorExpert systemKey (cryptography)Repository (publishing)Data managementOffice suiteRevision controlDistribution (mathematics)Social classChainIntegrated development environmentBinary fileStack (abstract data type)AuthorizationParallel portSoftwareDatabase transactionSinc functionMonad (category theory)Concurrency (computer science)Asynchronous Transfer ModeCode refactoringIndependence (probability theory)Software maintenanceComputer animation
19:03
Cross-site scriptingFront and back endsScripting languageJava appletContent (media)WebsiteError messagePrice indexDatabaseSource codeStack (abstract data type)DisintegrationInformation securityDependent and independent variablesFluid staticsTelecommunicationTable (information)Mathematical optimizationProcess (computing)DivisorFeedbackSoftware developerPersonal digital assistantEvent horizonStability theoryGroup actionTwitterMatrix (mathematics)EmailVector potentialMoment (mathematics)Process (computing)ResultantPresentation of a groupCASE <Informatik>CodeMultiplication signEmailOnline helpMereologyTraffic reportingProjective planeTerm (mathematics)FeedbackCombinational logicGroup actionStability theoryThread (computing)Software developerAdditionSimilarity (geometry)Address spaceInternet forumSystem administratorNumberMeasurementInstance (computer science)WebsiteElectronic mailing listArithmetic meanFormal languageFluid staticsMassLatent heatSign (mathematics)Information securityComputer fileScripting languageMetadataFront and back endsNoise (electronics)Dependent and independent variablesContent (media)Source codeDatabaseSoftware repositoryProgramming languageTelecommunicationQuicksortBasis <Mathematik>Goodness of fitData conversionTwitterMatrix (mathematics)Real numberSelf-organizationArchaeological field surveyKey (cryptography)File formatDivisorBitBus (computing)Public key certificateBelegleserRevision controlBroadcasting (networking)CuboidOrder (biology)Arithmetic progressionComputer clusterPressureSoftware frameworkStandard deviationRepository (publishing)ArmInternetworkingSatellitePhysical lawDifferent (Kate Ryan album)Library (computing)Coma BerenicesReading (process)System callFood energyMathematicsComputer animation
28:31
Program flowchart
Transcript: English(auto-generated)
00:06
All right, so our final talk for the Dev Room today is by David Christensen. He is the executive director of the Haskell Foundation and has worked with Haskell and functional programming
00:21
in both academia and industry. He was a major contributor to the first version of Idris and its Emacs mode. Together with Daniel P. Friedman, he wrote The Little Typer, an introduction to dependent type theory, and he's currently working on functional programming in Lean
00:40
and introduction to writing programs in Lean 4. His presentation today is Open Source Opportunities with the Haskell Foundation. Thank you, David. Thank you. So as a brief overview, I'll be presenting three major sort of categories of speech today, I guess.
01:04
A bit about lore and values of Haskell for those who are new to the community, a bit about institutions and projects that kind of keep us all up and going, and at the very end, I will plug my employer, the Haskell Foundation, as one does. So to begin with, lore and values.
01:22
Many people coming in here who don't know Haskell so well might be thinking, what is Haskell? And I'm not gonna answer that at all. I'm gonna answer another question, which is who is Haskell? And the reason why I think this is an interesting question to answer, well, my thinking was really influenced by this essay by Ken Pittman from back in 1994 called Lambda, the Ultimate Political Party,
01:42
which was kind of a riff on a series of MIT AI lab memos, Lambda, the Ultimate X, where X are things like op code and so forth, but, and most of this is a bunch of details about like the LISP standardization project of the early 90s, which is not so relevant anymore to most of us, but for those who are not historians,
02:04
the author makes a wonderful point where he proposes a thought experiment, and in this thought experiment, he says, take the LISP community and give them the C programming language. Don't let them talk to C programmers. Come back, check in after some time has gone by, and what should you expect to find? Well, you should expect that the version of C
02:21
that the LISP hackers had been hacking on has grown Lambda, it's grown garbage collection, it's grown like fancy interactive environments. It certainly won't run on low-end machines anymore, whereas you'd expect that C would be sort of basically like C, but better in the ways that C normally gets better, you know, like maybe Bool has become a type and things like that. This is from the perspective of 1994,
02:41
that was not the case yet. And what this really says is that the way we should understand a programming language is really as like a shared artifact for a community of practice, like a group of people who are working together on some project, and we're not all identical, but we all have something in common which draws us to this programming language,
03:01
and what this really means is that like the values of a community shape the development of a programming language over time, and the shape of the programming language affects the values of the community, because if you hate it, you're gonna leave. So what are some values of the Haskell community? Well, we think that elegance is a very important thing, very, very important,
03:21
but we also like to build things that really work. You know, there's a stereotype of Haskellers who, you know, like once their program type checks, they just like delete it because they're done, and that's not true at all. We really do like to build things, you know, I used xmonad for like a decade, but also we really do appreciate our mathematical inspiration.
03:40
You know, we like to sort of be able to look at a thing and say like, oh, from this branch of mathematics, this means this thing, and a few of us do that and the rest of us look at those people and say like, yeah, but as opposed to, ugh, right? We also really like playing with things, you know, like playing practical jokes in the type system is something that will get you respect rather than disgust in Haskell.
04:03
We have a real culture of like cludging through a thing and then cleaning it up and making it elegant and beautiful later. You're like, you're not expected to prove theorems and then do your work. It's more like find a thing that works and then see if you can prove something cool about it. We tend to be pretty anti-authoritarian and independent people. That makes my job as chief cat herder
04:21
more kind of like chief mountain lion herder, which is fun, and typically when we wanna make a thing that works well, we're gonna be using kind of lightweight semi-formal methods like, you know, fancy types or property-based testing, things like that as opposed to other processes that are used more so in the rest of the world.
04:41
We like cleverness. You know, if you can come up with a thing that's like fancy and powerful and cool, like people look at that and say yes. We tend to have low power distance. You know, if you go to a Haskell event and the person with like the gaggle of young Haskelers following them around says something and you talk back to them, you're likely to be met with respect
05:01
rather than with like rejection for having dared across the great leader. We like novelty. We tend to have a lot of respect for knowledge. We don't wanna say like, oh, like that's just book learning. We also tend to be a bit insular. There's a bit of like a not invented here thing that happens quite often in Haskell.
05:22
And also we've sort of mass imported a lot of random Unix stuff, like a preference for kind of grody command line applications. I think some non-values of the community. One is like achieving correctness through formal discipline organizational design. That certainly happens in some organizations.
05:42
I think more in the corporate world than in the open source world. But we also tend to not use traditional software engineering practices even when it might be relevant and useful because we just kind of look at that and say, huh? And also while we value simplicity and beauty in our language, the things outside of the language
06:02
we often look at and say, yeah, it's okay if that's a bit crunchy. So where's all this coming from? A community has values, but it also has history. Well, back in 1976, two very important things happened. The first was a paper by Dan Friedman and David Wise called cons should not evaluate its arguments.
06:22
Cons is the name of the list constructor in old school LISP and today in LISP today. Also David Turner made a new version of the St. Andrew static language, which was lazy. And this is sort of gave rise to a cottage industry of cool things that are not all on the slide here because there's too many of them.
06:41
One notable example in 1984 was lazy ML from Chalmers and also of course, Miranda in 1985. And as we all must note, Miranda is a trademark of Research Software Limited. And so then like a bunch of other languages came out like Orwell, you know,
07:02
Alphal, clean from the folks that I'm making a really great, interesting language with some cool ideas you should look at, Ponder. And then like, people are thinking, well, we've got this nice compiler over here. We've got this nice library over here. We can't use the library with the compiler because they don't, like they're different languages but there's not anything importantly different about them.
07:21
It's just that this one came from this university and this one came from this university. And to be clear, this was a very like university led phenomenon, all of this lazy programming in the 80s. And so a committee got together and in 1987 and through 1990, they started working on the sort of committee language that would, you know,
07:41
essentially shave off all the things like this one uses a single colon for the types. This one uses a double colon. You know, this one uses a capital letter for constructors. This one uses a lowercase letter and shave off those differences and make this language where, you know, you could use a library from the one site on the compiler from the other site. And unfortunately, when you get research, fortunately or unfortunately,
08:01
when you get researchers in a room together, they tend to do research and all of a sudden they figured out type classes and they started doing IO with monads and then Haskell was born. And the, yeah, yay. So the 1990s was like a period of furious hacking both on the definition and the implementation. The two kind of went hand in hand. There were lots of implementations of Haskell in the start,
08:22
you know, because the idea was that it would be a common standard for implementations sort of like in the sense more like C or Common Lisp and less like, you know, Python or Perl or Rust, which are sort of defined by their canonical implementation. You know, in 1992, work was started on GHC.
08:42
In 1995 on HUGS. Has anyone in here used HUGS? Ah, good, some hands. Yeah, so back in the day, GHC didn't really, didn't have a REPL, so you'd use HUGS for the nice interactive environment and the error messages and then you'd use GHC to compile your code, kind of like standard ML programmers do with like SML and J in Milton.
09:03
You know, and by the end of the 90s, we had the Haskell 98 report, you know, put together by the committee and by 2001, GHCI came out and I see this as like kind of a watershed moment because it's when GHC began starting to kind of serve all of the needs of the Haskell community rather than just the batch compiler
09:21
to make your fast code need. You know, in the 2000s, we had a fairly finished language standard, right? The Haskell committee disbanded itself after Haskell 98 came out in 1999. And a wall of work was put into making Haskell go fast, like let's make the compiler generate better code, let's look at all these nice optimizations we can do.
09:42
Also at doing like reliable concurrent programming, so we got a lot of cool like parallel Haskell features, we got software transactional memory, all this like space age technology stuff from the perspective of the mid 00s at least. And in the 2010s, you know, or I should say in 2009,
10:00
we got the Haskell 2010 report and that was actually the last major revision to Haskell and there isn't really a committee around anymore that feels like they can define a new Haskell language. And in some sense, this report was a little bit anachronistic because by this point, GHC was the Haskell implementation that everyone was using. Through the 2010s, GHC was extended
10:21
with all sorts of super fancy types. You've seen a little bit of them today, but there was this whole line of research of how can we extend the expressive power of the type system while still keeping a lot of the properties we like of Haskell, like being able to write down a simple program and have it tell me what the type should be, as opposed to having me tell it what the type is first
10:41
and then having it check the program. And we're only a little bit into the 2020s, but I think that what's happening here is that we're gonna finally deliver on our potential of having the best experience driven by the fancy types and the fearless concurrency and all these things, but we'll see what happens.
11:00
So a little bit about institutions. I've been talking a lot about sort of community and history but a community is more than just a group of people. There's also, you know, figures within any community who kind of set the agenda for that community, who others look to for leadership and inspiration from time to time.
11:20
And an interesting thing about Haskell, this comes up a lot in various discussion boards, is people will say, what is the Haskell X, right? Where X is drawn from the set containing build tool or tutorial or book or IDE or compiler or whatever. And in fact, we can't answer that question because unlike something like, you know, Python or Rust
11:44
or many other of these implementation defined languages, there isn't really any organization that owns Haskell and can say, we're going to now say that this is the official Haskell X. And, you know, like we're essentially defined by GHC,
12:00
but it doesn't have, the GHC project doesn't have this kind of leading role in the same way that like the Python project has in Python. So we do have various committees that are, you know, that exist and people mostly do what they say. And like I said, we're a fiercely independent
12:21
bunch of people. So there's the core libraries committee and they're the ones who are maintaining and controlling the standard libraries. So things like strings and lists and all the basic stuff that you need that essentially every Haskell program is going to need, either directly or transitively through other things. Then we have the GHC steering committee.
12:42
And the name of that committee is a bit misleading. In fact, what they do is they evaluate changes to the language implemented by GHC. So in some ways, this is the forum in which changes to Haskell are discussed. And if you have input about it, that's where you should show up. Also, if you'd like to participate, you know,
13:02
they regularly have new nominations. So it's a place that you can do that. And then we have the Haskell.org committee, which is responsible for administering the Haskell.org site. And that's both the website, but also like the subdomain namespace. So when I needed to get errors at Haskell.org for a thing, they're the ones that I went to and asked.
13:21
And they also, for historical reasons, run the Google Summer of Code or Haskell Summer of Code when there is no GSoC. The key tools in Haskell, as we've seen earlier, there's the major compiler GHC. We've got HLS, which gives us all those fancy features that we saw earlier in the talk.
13:40
There's Cabal and Stack are the two major build tools. There's GHCUP, which is like a tool chain installation and management program, which is quite convenient to use. There's Hackage, which is kind of our CPAN or CTAN or crates.io, or depending on where you come from, one of those might make sense to you, which is a centralized repository of packages.
14:01
Luckily, we've just got one of those. Stackage is a version pinned distribution of packages from Hackage that have been tested to work well together so you can get a coherent set of stuff. These days, like in the old days, as the name suggests, Stackage used to work with Stack. Now you can also point Cabal at it as well, if you want.
14:21
And then there's Haddock, which is a documentation generator and it's in need of some serious refactoring. The maintainer's sitting over here. So if that's something you'd like to get involved with, you should go talk to them, because that could be a really useful way to help out. Also, GHCUP, I know, is looking for a co-maintainer to share some of the burden there. So that's another good place to get involved
14:40
where you don't have to be a super-type system expert. Tom Spading's Haskell Playground is looking for volunteers as well. This is a sort of up-and-coming project to have a sort of online place where you can go put in some Haskell code and run it and see what happens without having to install anything on your machine or anything like that. So you can think of it as like,
15:01
especially like an active paste bin. And you can go look at, I've been instructed to tell you to look at the help wanted and good first issue labels on the issue tracker. And mentorship is available from the author. The Haskell Foundation is the other institution that I didn't talk about with the first ones. We're a very, very new nonprofit,
15:21
just a couple years old. And we are trying to broaden the adoption of Haskell because a programming language is more useful when more people use it. So the more people we can get making cool Haskell stuff, the better it gets for all the rest of us. Also, we think that there's a lot of really good things in Haskell that haven't, like good ideas that haven't spread as far as they could yet. Like, you know, the rest of the world
15:40
definitely deals with first-class functions now. So we've succeeded there. The rest of the world is basically catching on about monads. So we're succeeding there. But there's a lot of other cool stuff that I think we still have that, you know, if we wanna make the world a better place, we can spread those good ideas. And the point of the Haskell Foundation
16:01
is not to come in and like take over everything. Our goal is really to support existing processes from our fiercely independent Haskell community and figure out what, you know, opportunities to help out. I am the executive team. So I've been in that role since May of 2022. So I'm still fairly new at it.
16:22
I used to work at Galois and beyond digital. Before that, I have a PhD from IT University of Copenhagen from 2015. I also did a postdoc in Indiana University. I worked on it as one and I helped write the little typer and I'm working on functional programming in Lean. So as you can see, I'm into like dependent type stuff, but that's really not the focus
16:41
of where I'm working in Haskell. I think dependent types are cool, but there's way more cool things than just that. The other full-time person we have at the Haskell Foundation is Brian Richter, who you may know online as ShriCAT. I'm actually not sure how to pronounce that. C-H-R is a consonant cluster found in my own name, but nonetheless, unusual in English.
17:01
But he's doing full-time DevOps and CI work for the GHC project and helping to unstick things there and make it easier for both the existing team and new contributors to work on it. He's also looking for volunteers to help out. So if you have knowledge of CI and DevOps things generally, and in particular GitLab,
17:21
Nix, Python, Bash, and or PowerShell, get in touch with him and he'll put you to work doing useful, interesting stuff for GHC. Another project of the Haskell Foundation is the Haskell Error Index. So this is a new website which you can get at errors.hascal.org. It really got its start at ZeroHack last summer.
17:43
And the way this works is that participating Haskell development tools, and so far there's three, that's GHC stack and GHC up, can assign a unique code to each of the error messages and warnings. And then these can be looked up on this website. And the website contains, for a given error message,
18:04
detailed description of it that's sort of longer than you could put in the error text itself. It can contain any number of examples. So ideally we're gonna be providing sort of a before and after example, like a program that exhibits the error message and then one in which it has been fixed, along with details about why that program
18:22
exhibits the error message. I could really use some volunteer help on this one. So if you're good at CSS and JavaScript, then dark mode support would be super useful. And also, we've put some work into the CSS, but it could use more. Like it's not the most beautiful of websites yet.
18:42
Also writing documentation content is super useful if you know enough Haskell to understand one error message and you can write a markdown file and use git, then you have the skills necessary to contribute documentation for one error. So far we have 72 in there. I hope that with the new GHC release coming out that supports the error codes, we'll quickly get the 371 remaining errors documented.
19:06
No, 271. And also if the site backend is a static site generator written in Haskell using the hackle library, and right now the deployment script takes too long to run, and if you can help me with the caching to fix that,
19:21
that would be awesome, because I'm terrible at that stuff. As you saw earlier, Frasier is running our security advisory database. This is a new project, a new initiative, to sort of inspired by the Rust and NPM advisory databases. The idea is that it's going to serve as a data source for tools like CabalStack and Dependabot.
19:42
And in particular, a lot of organizations that want to use Haskell need to pass ISO 27001 certification, and doing that is certainly possible without one of these automated scanners, but then you have to have a conversation with the auditor that makes things slower and riskier and more expensive. So if you can just check the box, that's much better.
20:00
Also, there's real value in finding out whether or not one of your dependencies has some sort of a known issue. Volunteers are wanted for the security response team, which is going to be administering the actual contents of the database, but also for tool development. It would be great to be able to sit down and say, you know, Cabal audit, or Stack audit, and have it spit out a list of things to look out for.
20:22
And also, some public communication help could be useful. Right now, we have a data format for the database, but generating a nice website that documents everything and is searchable would also be a really useful contribution. We have a podcast, the Haskell Interlude Podcast, which is looking for guests,
20:41
members of the Haskell community. So if you'd like to get on there and have a discussion with some leading Haskellers about what you're up to, that would be really cool. Email podcasts at Haskell.foundation. The Haskell Optimization Handbook is an in-progress text on how to make Haskell code go fast.
21:02
I blurred out the address on there a little bit, just because it's in the process of moving from one address to another one. But if you Google it, it'll come right up. This is being organized by Jeff Young, who works at IOG. He's known as DoYouCanDo on the internet, so you can get ahold of him if you'd like to find ways to contribute text or infrastructure to this project.
21:23
In addition to all of these concrete technical things, we're also orchestrating the Hackage security signing process. So Hackage uses an instance of the update framework, which is a standard way of securing software repositories against man-in-the-middle attacks,
21:40
and untrusted mirrors, and these kinds of things. And part of this process is that we have a collection of trustees who have keys, and any three of them have to sign the metadata file from time to time just to keep the thing going. And they're certifying that all of the associated roles are correct.
22:00
And that's been a volunteer-led process in the past, and we've had a couple of times where we thought, uh-oh, we gotta sign this real fast, otherwise things are going down. And so the HF is by being a professional organization, we can put a thing in the calendar and get the process going in plenty of time and all of those things. Also, we're gonna be doing a lottery factor audit
22:22
of key projects and infrastructure soon and try to find more places where we need to recruit extra maintainers for important projects and that kind of thing. Some people call the lottery factor a bus factor, but I'd rather think in terms of how many people can win the lottery and retire from computing forever without the project collapsing. Seems a little happier. We've also spent some time helping out the GHC developers.
22:43
The results of this end up on discourse.hascal.org, typically. Recently, they asked us for some help in going out and surveying a certain number of GHC users about priorities for the next six to nine months, and then we collected feedback on that
23:00
and then developed a report where they said what they're actually gonna do based on the feedback. So this is available to be read. And right now, we're trying to do something similar for a project on making nightly releases easier to get to. So right now, you can get nightlys if you know the incantation, but we'd really like it to be super easy to get ahold of them. And so if you think that you could use
23:22
nightly releases for something, then please go find the discourse thread in post because that way we make sure that whatever solution we have incorporates your use cases as well. And I've already discovered a few that I hadn't thought of, so that's been a useful process. We are organizing a workshop for new GHC contributors.
23:40
So if you'd like to get started on hacking GHC but don't yet know how, then you should come to zerahack three days before zerahack and get an introduction. This is still an in-progress thing. We don't have a specific speaker list yet. Simon's definitely talking, but the rest is depending a little bit on a survey that's out there.
24:00
So if you fill out the survey and say what you're most interested in learning to hack on, that'll affect the people who we invite to come and present parts of GHC for potential contributors. And also if you know how to run a hybrid event well, get ahold of me. I don't. I'm gonna do my best, but if you could spare 45 minutes on the phone with me to tell me all the things I'm about to do wrong,
24:22
that would be very valuable. So email me if that's a thing. We have two big working groups at the moment. We have a technical working group which evaluates various project proposals and especially proposals where Haskell Foundation, administrative time or money would be useful.
24:41
And so if you have something like that, please come and give us a proposal and we'll discuss it and try to refine it and eventually hopefully fund it or administer it or otherwise carry it out. We've also used this to host a community RFC process in cases where that's needed because as I said earlier, there isn't really anyone who owns Haskell. So it seemed as good a forum as any
25:01
to have some of those discussions. And we have a stability working group which meets every two weeks and we're looking at, which involves GHC developers and academics and others and we're trying to find ways to reduce the difficulty posed by updates to the Haskell ecosystem.
25:21
And that's gonna be some combination of social and technical means over time. Lots of small stuff. Thank you for listening. My, if you wanna get ahold of me, I'm David at Haskell.foundation or I'm Kristiansson on matrix.org. And then the Haskell Foundation itself is Haskell.foundation. You can also look at Haskell.org
25:41
to find out more about Haskell itself. We have, we're on mass on Twitter as well and the names are up there. And I got, I believe a few minutes, five minutes left. So if there's any questions. Oh, yeah.
26:12
Thank you, that was a great talk. So I observe like what Haskell Foundation does and there was like a lot of great initiatives
26:21
and I think it pushed the language forward. But I'm wondering, so does Haskell Foundation measure somehow how popular Haskell is? Like every other month, there is like a thread that Haskell is dying. So I was just wondering like, do you have some like a concrete data that would say otherwise,
26:41
like that, I don't know, like a job postings are growing or the number of companies that using Haskell are growing or like the community is growing somehow. Like do you gather some data like this? Not particularly, no. I haven't found a good way to do it that I think is gonna be more signal than noise.
27:04
I don't think Haskell is dying. I think that there's a couple of people who feel that way and they're entitled to that feeling and they say it regularly. But I don't think that that's a commonly held feeling is my impression. I get the impression that's more a feeling that a couple of people have.
27:20
I know that I keep hearing about new users of Haskell who I'd never expected because they're not very public about it. Hackage continues to grow. I see job posts on a regular basis which I didn't see a couple of years ago. So those are all sort of anecdotal qualitative kind of things.
27:41
Yeah, if you have ideas about non-misleading measurements that are sort of cheap enough that I can do them being essentially one person with a, not tiny but not infinite budget then. Yeah, definitely. I'm not saying it's easy. I was just wondering if you maybe do stuff like this.
28:01
Yeah, as you know from my background, as you could see from my background, it's very much on the programming language side rather than the market research side. So if you do have good resources, I'd love to hear them. Sure, yeah, thanks.
28:20
Okay, any more questions? It seems not, so thank you very much, David.