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.

Alyona Antonova is a Software Engineer with Serokell. She likes to spend time learning new things – about the world or about herself.

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

Andrzej Rybczak is a professional Haskell developer with 10 years of experience and author/contributor of multiple open source Haskell libraries used in production (notable examples: effectful, optics, log-base, hpqtypes). I've also contributed patches to GHC. Hobbies include walking among nature and dancing :)

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.

Edsko de Vries has been using Haskell for nearly 20 years, and has been a professional Haskell consultant with Well-Typed for roughly half that time. He holds a PhD in advanced (substructural) type systems for pure functional languages from Trinity College, Dublin.

As a Well-Typed consultant, he has provided training across the world, from Johannesburg to Boston to Singapore. He has worked on a large variety of projects, both open source as well as closed source for specific clients. Some of the open source projects he has contributed to are Cloud Haskell, Hackage, the Hackage security library, ghc, Ziria (a DSL developed by Microsoft) and cabal. Some general purpose libraries he has (co)developed include generics-sop, nothunks, recover-rtti and large-records.

The last few years he has worked as a consultant with IOHK on the Cardano blockchain, where he was responsible for the overall architecture of the consensus layer, designed the hard fork combinator, and did research on formal specification of a crypto wallet and invented a novel coin selection algorithm.

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.

Facundo Domínguez is a software engineer at Tweag. He has been using Haskell in industry during the last two decades, and he is a long-time contributor to Haskell libraries and GHC. Of late, he has been contributing to Liquid Haskell to make it easier and faster to use until it takes over the world.

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.

Gabriella Gonzalez is a functional programming evangelist best known for her blog, Haskell for all (haskellforall.com), and also for authoring the Dhall configuration language (dhall-lang.org). She not only promotes functional programming languages, but also draws inspiration from them to rethink and simplify imperative programming architectures. When she's not contributing to open source (@Gabriella439) she frivols away her time on Twitter (@GabriellaG439).

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](https://bazel.build/)] 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 rules_haskell and a survey of the current state. If the talk is successful, the audience will earn an intuition of when rules_haskell could be worth adopting.

Georgie Lyubenov had his interest in logic and functional programming languages sparked by his university and he has been on a quest for perpetual improvement ever since. After 4 years of Haskell and Elm programming and teaching, he came to Tweag to expand the breadth of his knowledge by working with Nix and Bazel.

His more popular open source work involves helping migrate hlint, doing busywork around polysemy, fixing bugs and implementing features around the Bazel+Haskell ecosystem, as well as occasional minor involvement in ghc.

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!

Gergő Érdi has extended GHC by adding pattern synonyms, used SMT solvers to analyze old text adventure games, and programmed AVR microcontrollers in Rust before it was cool. Lately, his chaotic interest turned to Clash, the Haskell to FPGA compiler. This led to him writing two things: the "Retrocomputing with Clash" book, and self-introductions in the third person.

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!

Martin Janiczek loves to start things and little one-off experiments. He has a drive for teaching and unblocking others.

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!

Michał J Gajda is a bioinformatician turned data scientist, turned banker, turned software startup founder. He loves to mix the best of science and programming methodology into tasty dishes of ultimate utility.

Our mental models of the world inform our actions. Capitalism forces companies to act in unsustainable ways. Can reformulating this in terms of pure functions and monads shed light on this problem? We will argue, "yes", with some examples and implications that come from this way of thinking, as well as some resources and open questions for those willing to explore more.

I'm a long-time programmer who has recently become extremely passionate and interested in the climate emergency. I've been working as a Haskell programmer for the last few years, after a bit of a diverse (programming) career in different fields from creative AI, teaching, and quantum computing. I spend most of my time reading books, and posting some small reviews - https://betweenbooks.com.au/ - and otherwise am really interested in community building, connecting people, kindness, and understanding how to build a sustainable business.

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.

Rahul Korthiwada works as a software developer for Juspay. He completed his undergraduate studies at IIIT Guwahati, where he developed a stronger enthusiasm for functional programming, selecting the best framework, and adding value.

This talk will look at safety in Haskell and in financial transactions in particular, before offers 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.

Rob Harrison is a Lead Architect and Senior Manager at Flowmo.co, a software development agency and consultancy based in Cornwall, UK. After founding a couple of tech startups Rob worked in product development for most of his career, before moving to agency-based development in the south west. He has been a technical lead on projects for clients such as Vodafone, Tesco, Foot Locker and Winsor & Newton. Rob is a specialist at delivering scalable, redundant and highly available container-based architectures; most recently for processing and storing data at scale. His current product for client Vodafone uses Haskell in combination with open source technologies to validate huge quantities of invoices per month.

"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."

Rohan Mehta is a current high school senior with a driving interest in applied math, and how it intersects physics, biology, and computation. He is an AI literacy and synthetic biology advocate, and regularly holds workshops to expose middle and high schoolers in his local community to ideas from these fields. He is also a functional programming zealot, and loves expanding his programming language repertoire in his free time (currently, he is trying to tackle Rust). Professionally, he is a Research Fellow at the Wolfram Institute and independent machine learning researcher at the ML Collective. On the side, he enjoys playing tennis and golf, reading dystopian sci-fi, and writing on his blog.

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.

Sandy Maguire  is an independent researcher, who spends his time dabbling in Haskell. He is the author of Thinking with Types, Algebra Driven Design, the polysemy library, and the Wingman extension for the Haskell Language Server. By day, he likes strumming guitars.

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.

Simon Marlow is a software engineer in the Code Search and Indexing team at Meta. For much of his career Simon has worked on the Haskell language, building large parts of the GHC compiler and its runtime system, and authoring various research publications on language design, compilers and runtime implementation. While at Meta (previously Facebook), Simon designed Haxl, a Haskell-based domain-specific language used by teams fighting abuse on Facebook. Currently he works on Glean, a system for indexing and querying source code at scale. Simon is the author of the O'Reilly book "Parallel and Concurrent Programming in Haskell".

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.

Trevis Elser works with teams writing real-world applications in Haskell as well as helping team members with little to no experience in the language get up to speed. His focus is delivering high-quality and maintainable systems using practical Haskell, along with other tools. Other interests of operating systems, security, choice, and usability, drive Trevis during spare time.

Lyle Kopnicky has been writing Haskell since attending the Oregon Graduate Institute in 2001. He has written production Haskell code at Janrain and TripShot, but has written a lot of Perl as well. He led the Portland Functional Programming Study Group for three years. He is the author of Vintage BASIC (a BASIC interpreter written in Haskell), and a library for verifying natural deduction proofs.

"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."

I'm a software engineer and I'm into compilers and pure functional programming. I'm doing Research & Development. I'm working on the GRIN Compiler Project. (GHC, LLVM, ASM, pointer analysis, optimization)

Haskell is a fantastic language, but it can also be alien, because it is different from other languages in many ways. In this introductory talk we will focus on one aspect particularly that makes it rather unique: In Haskell, side-effecting programs have different types than
programs without side-effects.

In this introductory and example-driven talk, we will look at the background of this idea, show why it is useful and can lead to better code, and how it interacts with many of the other programming language features Haskell has to offer.

Andres Löh is a Haskell consultant and co-owner of Well-Typed LLP. He is based in Regensburg, Germany. He started using Haskell in 1997, when being an undergraduate student of mathematics in Konstanz and has been an enthusiastic functional programmer ever since. Andres obtained a PhD in Computer Science from Utrecht University in 2004, on extending the Haskell language with capabilities for datatype-generic programming. After having been a university lecturer for several years, he joined Well-Typed in 2010.

In this session you will learn about three heros: Monoid (and its side-kick Semigroup), Foldable and Traversable. Three amazing type-classes, each providing a set of astonishing powers, making your daily programming routines easy as pie.    During the talk we will encounter numerous villains (a.k.a programming riddles). Though the baddies look tough at the first glance, we will quickly learn that with the help of our protagonists, defeating those villains is a child's play.  Are you ready to meet our heroes and master their powers?  The talk is appropriate for Haskell beginners. We assume familiarity with basic Haskell syntax (functions, data types, typeclasses).

Paweł Szulc is a Haskell developer by day, Haskell developer by night. Explorer of uncharted territories. Father, husband, cats herder.

Imperative languages allow for iterating through all the elements of a collection using `for` and `while` loops.

Functional programming, on the other hand, does not adopt such constructs and identifies recursion as a better way to loop over a collection of elements. Functions, like `map` and `filter`, are then used to capture and expose looping patterns.

This shift of perspective is one of the first differences beginners notice when they start approaching functional programming coming from an imperative background.

Getting accustomed to looping with functional combinators, and building good heuristics about their usage, will certainly help you to improve your grasp on functional programming.

Join Marco in his exploration of functional loops and gain a solid foundation from which to continue learning functional programming.

Marco Perone loves to learn, experiment and try new things. He is interested in ideas, patterns and software architectures, with a definite preference for code quality and functional programming. Marco is a mathematician turned into a software developer.

Lover of precision and formalism, he enjoys writing high quality software, constantly looking for ways to create safer and more reliable code.

Particularly interested in functional programming, its links to domain modelling, and how to introduce and apply its ideas in non-functional languages.

When he is away from the keyboard, you can probably find him hiking on a mountain or riding his bike around Europe, or most probably eating some good dark chocolate.

One of the hardest things about learning Haskell is figuring out how all the pieces fit together. Maybe you've learned a bit about lazy lists and magnificent monads, but it's hard to know how to put those ideas together to make a real program.

In this workshop-style talk, you'll learn how to put the pieces together and build a working command line application from scratch. During the talk you'll see how to design and refactor the architecture of a Haskell application, how to set up a new project with cabal, learn how to design functional
data structures like zipper lists, and get hands-on experience with common patterns like monad transformers. This talk is appropriate for beginner and intermediate Haskellers. You can enjoy the talk on its own, or use it as a companion piece to chapters 8, 9, and 13 of Effective Haskell.

Rebecca Skinner is a software engineer with over 10 years of experience in Haskell and functional programming across industries including fintech, security, cloud infrastructure, and data science. She's a lead software developer at Mercury, and the author of the book Effective Haskell.

Look at the clouds, you can see a bright shining light, is the sun? No it is WebAssembly(WASM)!

WASM has shown to be an ideal format for creating platform- and language-independent programs, despite being first created for the web.

Thus this talk shows how Haskell fits in the WASM ecosystem. This brings into focus: Asterius (https://github.com/tweag/asterius). Asterius is a Haskell to WASM compiler. It compiles Haskell source files or Cabal executable targets to WASM+JavaScript code which can be run in Node.js or browsers.

Today there are a number of popular Haskell-based applications, running in the browser like diagrams, ormolu, pandoc, and todomvc. Thus bringing into the great applications provided by Haskell and making them widely accessible with the help of WASM.

Through this talk learn how to compile Haskell applications into WASM and then use that in a web application with the help of a live demo.

The talk will also cover some of the interesting use-cases for this translation including Cloudflare workers, use of Asterius in creation of WASM-based microservices using Spin.

Shivay Lamba is a software developer specializing in DevOps, Machine Learning and Full Stack Development.

He is an Open Source Enthusiast and has been part of various programs like Google Code In and Google Summer of Code as a Mentor and has also been a MLH Fellow. He is actively involved in community work as well. He is a TensorflowJS SIG member, Mentor in OpenMined and CNCF Service Mesh Community, SODA Foundation and has given talks at various conferences like Github Satellite, Voice Global, Fossasia Tech Summit, TensorflowJS Show & Tell.