What if accurate semantic information about your code was available through a rich query language that produced results in milliseconds? And what if that worked at scale, so that you had information not just about the files you're working on, but the entire stack in which your code lives? You could use that to build IDE integration, code search and browsing tools, code analysis tools, as well as any ad-hoc tooling or infrastructure that needs accurate semantic information about code.

At Meta we're building Glean, an open-source system for storing and querying information about code at scale. Glean is implemented mostly in Haskell, using the open-source RocksDB engine for storage. Glean comes with indexers for several languages.

In this talk I'll take a tour through what Glean can offer, with a particular focus on how Haskell has enabled some rather nifty features that make working with Glean safer and more efficient.

Liquid Haskell (LH) is a tool regarded to verify programs. In this talk, however, we will look at using it as a tool to understand what a program is doing via specifications. We will look at a gnarly function (Data.List.permutations) from the base library and show how its meaning can be unraveled by writing down specifications for each piece of the implementation, while having LH prove that the pieces really do what the specifications say!

This talk targets universal engineering needs like explaining how a function works, verifying that the explanation is accurate, and ensuring that it stays up-to-date. The lack of documentation of the chosen function had an observable impact in the community this year [1]. LH is attractive to solve these problems because, unlike other approaches, it doesn't require extending the Haskell language, and it reuses the effort that goes into developing dedicated tools to reason about logic like SMT solvers.

FPGAs can bring the versatility of custom chip design to the desktop of the hobbyist. But what does it look like to actually make something fun out of an FPGA, and how can Haskell help with that?

In this talk, we'll find out what an FPGA even is, and then learn just enough Clash to build, in full detail, a fully functioning Flappy Bird circuit. Turns out, all we need to do is count to 419,200 and the rest just follows!

There are many tools to implement web apps. While Haskell is not the most popular backend language for web development, it also deserves attention. And to get this attention, we should talk about the variety of frameworks with their strong and weak spots, talk about modern user-friendly tools, show real-world examples, and so on. Thus, the first goal of my talk is to promote Haskell as a good web development tool.

However, using Haskell as the primary backend language implies choosing among plenty of web frameworks. I’ll try to give general guidance on how a choice of the most relevant one might be approached, and give tips on when each framework will be more appropriate.

Firstly, there will be a short overview of popular frameworks like Servant, Obelisk, IHP, and others. Then we’ll implement a simple app using a couple of them to display the differences in practice and show the pros and cons of each framework. Furthermore, we’ll consider what happens if we add a non-trivial functionality to our app.

I hope my talk could make the life a bit easier for (future) Haskell web developers.

In this lightning talk, Csaba Hruska will talk about the utility of a possible GHC Whole Program Compiler (WPC) patch/design, and the corresponding use cases for backend and tooling development from both a research and industrial perspective.

One of the most common complaints about GHC is that it is "slow". In this lightning talk, Alexis talks about the work TWEAG is doing to help speed up GHC.

In this talk, Adam Jones and Ike Feehi discuss Signify Technology's unique, high-quality-driven approach to recruitment around Functional Programming languages.

Popular methods for handling effects in monadic computations (in particular the mtl library) bring with them several subtle issues. When encountered, these issues tend to confuse non-experts and require debugging to find out what's going on, while (in the worst case) your application no longer works.

I'll walk the audience through what these issues are [1] and how the effectful [2] library solves them. I'll also talk about its design philosophy and how it's able to improve over the status quo in terms of semantics, performance and interoperability with the existing ecosystem without making significant sacrifices.

[1] https://github.com/haskell-effectful/effectful/blob/master/transformers.md [2] https://github.com/haskell-effectful/effectful

This talk will look at safety in Haskell and in financial transactions in particular, before offering an introduction to basic Category Theory in the context of real world business code.

As lead of the Vodafone Germany project, Rob will talk about the work his team is doing for Vodafone Germany and UK using Haskell to revolutionise Vodafone's invoice verification and saving millions of Euros in the process.

This project uses a number of technologies to provide fault tolerant auto-scaling and parallel processing. He'll share how they sold the project to the client and how Haskell fits into that project, where more Haskell could have helped, and ultimately client satisfaction with Haskell-based deliveries.

Finally, Rob will dive into how they are utilising Category Theory to prove correctness and perform meta-programming.

Quadtrees are well-known containers for spatial data, but little attention has been given to them in a functional setting. In this talk we will explore the design space of quadtrees and find reusable techniques to discover elegance, in both their design and implementation.

"I am a high school student (current senior) who first discovered functional programming in the 9th grade, through Clojure. I was so taken in by the idea of FP that I decided to explore other languages that used the paradigm as well, which invariably led me to Haskell. The culmination of this interest was the first ever iteration of the Paradigm Conference, a conference hosted by a team of high schoolers (including myself) from around the world, completely for high schoolers and all about FP programming languages that are underrepresented in high school CS curriculums. Of the languages in the event, Haskell (perhaps unsurprisingly) was the clear favorite. In this talk, I would like to reflect on what attendees of our event learned technically from attempting our Haskell coding competition and building things like a Haskell bot which transcribes Discord notifications to Whats App, as well as what educational resources we released to guide them through the Haskell acclimation process. Finally, I'd like to end by making a case for why learning FP and Haskell in particular should have a place in today's high school CS curriculum and what else (other than Paradigm Conf 2023!) we can do to increase young programmers' interest in the language."

Since joining Epic Games in late 2021, I have been involved in the design and development of Verse, a new, declarative programming language that Epic plans to use as the language of the metaverse.

Verse is a functional logic language, with a bunch of innovative ideas. Like Haskell Verse is declarative (a variable in Verse stands for just one, immutable value), and higher order (lambdas are first class). But Verse goes well beyond Haskell, with existential variables, unification, expressions that yield multiple values, and more besides. In this talk I'll give you a sense of what functional logic programming is about, what it looks like to program in Verse, and how we can give meaning to Verse programs using rewrite rules.

Live coding is a holy grail of fast development loop: see changes to the server immediately, leave code to be developed until it is needed, and never need to manually replay the game when developing it.

But can a beginner learn it?

Yes! And one should, since it will greatly speed up your development process.

In this talk, Michal proposes a simple way to do live coding and event sourcing Elm-style during the development of a game using Haskell. This method is the product of a long effort to reduce the effort and complexity of debugging and writing interactive software, and it is recommended for all Haskell beginners!

We at Juspay use Haskell in production for most of our critical services and have about a million lines of code. We constantly look for opportunities to simplify building scalable services by making the best use of higher order abstractions. We see Monad as an abstraction over execution strategy and we also found workflows to be a common use case across various application but still we feel we miss a common framework. Therefore, we created a workflow monad that enables programmers to write workflows as goal trees in a do block. Workflow monad is an enhanced state monad that also abstracts out what needs to be persisted between every step and the logic that needs to be used to skip a step on a retry of the workflow. We believe that the workflow monad would provide a common framework for any workflow across our services to be reliably written with ease.

Has your project outgrown rcabal-install or stack? Do your Haskell builds need precise integration with other build systems? Learn when rules_haskell might be the right choice for you.

rules_haskell [[1](https://haskell.build/] is the extension of Bazel [2] to build Haskell programs. Bazel in turn is a tool that aims to make fast compilation of large code bases feasible. The capabilities of rules_haskell overlap with those of cabal-install and stack , so why bring yet another choice to the table?

This talk provides an overview of the strengths and weaknesses of ruleshaskell and a survey of the current state. If the talk is successful, the audience will earn an intuition of when ruleshaskell could be worth adopting.

At TripShot, we felt that the usual way of constructing non-empty lists was asymmetrical and awkward. I set out to create one that could take a variable number of arguments.

This turned out to be surprisingly tricky, even though I thought I had a model to start with: printf. A colleague pointed out Donnacha Kidney's post about liftAN. This came closer to what I needed but still didn't quite match my problem. I was able to construct a solution that merged these elements with some additional insights and language features to construct a solution I was happy with.

As an attendee, I would enjoy a talk like this, because I feel that there are many pre-packaged solutions that seem to be spun from whole cloth, and that can be intimidating. By showing the process by which I developed this solution, I hope it will seem less like magic, and encourage others to attempt to solve similar problems.

Haskell is used in the enterprise, but the story hardly stops there. The language and ecosystem present many options, what choices are being made to facilitate mainstream development? What are the pain points? What tools are used? Do enterprise organizations expect things that are missing? How is the language itself used? Here we journey through the maze of choices with the language and the ecosystem, explore concrete choices that have been beneficial, and more.

This session follows up on last year's, Haskell in the Enterprise: A Report from in the Belly of the Whale, offering new lessons for teams using Haskell in the enterprise.

Property-based testing (PBT) is a valuable tool in the functional programming world: it generates test inputs for you (finding tricky edge cases you wouldn't be able to find manually) and lets you specify and verify laws and invariants about your code with ease. Virtually all PBT tools nowadays shrink the failing inputs to a minimal (and thus much more helpful) counterexample before presenting it to you. Implementing shrinkers can be tricky, though. I'll walk through the common shrinking algorithms (seen in QuickCheck, Hedgehog, ScalaCheck, etc.), their inherent problems, and most importantly: how to implement shrinking in a way that doesn't suffer from them!

Substructural type systems such as linearity, uniqueness, or ownership track sharing of values in the type system. Haskell’s type system supports linearity through the experimental LinearTypes; the closely related concept of uniqueness has been a central component in the type system of the Haskell-like programming language Clean for over 25 years. The increasing popularity of Rust introduced the world to an imperative language with a similar concept: ownership. This talk will be an introduction to these concepts, as well as a comparison between these different systems.

Fall-from-Grace is a functional programming language project designed to be easy for others to fork to build their own domain-specific languages.

Fall-from-Grace is inspired by the Dhall configuration language, but boasts a few improvements such as JSON-compatible syntax, bidirectional type inference, and row polymorphism.

This talk gives a tour of the language's features and concludes with a demo web application that compiles Grace functions to interactive web forms.