PureScript is a Haskell-like language that compiles to JavaScript. If you like Haskell, you will find yourself completely at home with PureScript. However there are a few interesting typelevel things from Haskell that are not provided by the PureScript compiler. The Type reification machinery is one of them.

In this talk, we'll understand the concept of type reification and its implementation using the Typeable typeclass. Essentially, using Typeable we can take a runtime value and get a value level representation of its type called a Typeref, this process is called type reification, which we can then compare with other known typerefs. We'll discuss indexed and unindexed typerefs and some real world problems that can be solved by this sort of type reification.

A significant part of the talk will involve details of how Typeable is implemented in Haskell, and how it can be approximated in PureScript even without compiler support (available as a library https://github.com/ajnsit/purescript-typeable/). We'll also discuss some alternatives approaches and their pros/cons.

We introduce a Strongly Typed Workflow DSL for Haskell called ActiveTasx, which allows writing Multi-User, Interactive, and Effecful workflow applications at a very high level.

We will discuss the benefits of building ActiveTasx as a DSL in a functional programming language.

For example, ActiveTasx improves upon existing imperative Workflow engines by using Functional Programming and design principles. It allows you to compose smaller workflows together using combinators, to build progressively more complex workflows, and the resulting workflows behave predictably at every step.

ActiveTasx also exploits Haskell's laziness to allow self referential and infinite workflows without any extra syntax.

Since the Workflows are first class in the DSL, it's also possible to pass them around, creating "Higher Order Workflows". For example, it's possible to create a workflow that allows a user 'A' to choose a workflow to assign to a different user 'B'. Again this is all possible without having to build any special handling in the language for this.

Workflows created with ActiveTasx also come with -

1. An automatically generated web user interface with authentication, and wizard like steps for providing information.
2. Websocket based fast communication between client and server.
3. Automatic data persistence.

UPDATE: Please setup https://github.com/ajnsit/purescript-react-starter (follow the instructions in the README) on your laptops as a **prerequisite**.

Purescript is a purely functional, strongly typed language, that compiles to Javascript.

It provides several high quality libraries for frontend development, and comes with excellent tooling and editor support that makes writing code a snap!

In this talk I will provide a quick introduction to some basics of Purescript, and then dive into an interactive demonstration of building a non-trivial web application from scratch. I will show how to interface with React bindings, and how to interface with some existing Javascript libraries (a React UI component lib).

The presentation will be interactive and similar to an inpromptu talk I gave which is linked below. However, I will also demonstrate live coding of an actual purescript application which people can follow along.

Bring your laptop to follow along.

We'll discuss how to use strongly typed functional programming to build a typesafe and highly declarative DSL to generate SQL, that allows better abstractions and minimises runtime errors. We'll focus on type systems, and build an intuition for row types and how it guarantees correctness for SQL. I'll cover some parts of actual SQL generation.

A similar talk was given at IIIT Delhi earlier, however that was more geared towards beginners to Functional Programming (link below). I plan to give a more intermediate level talk this time.

A virtual cottage industry has sprung up around Purely functional UI development, with many available libraries that are essentially just variants on two distinct approaches: Functional Reactive Programming (FRP), and some form of functional views like "The Elm Architecture". After having worked extensively with each of them, I have found that none of the approaches scale with program complexity. Either they are too difficult for beginners trying to build a hello world app, or they have unpredictable complexity curves with some simple refactorings becoming unmanageably complex, or they "tackle" the scaling problem by restricting developers to a safe subset of FP which becomes painful for experienced developers who start hitting the complexity ceiling.

In this talk I give an overview of the current Purely Functional UI Development Landscape, and then present "Concur", a rather unusual UI framework, that I built to address the shortcomings of the existing approaches. In particular, it completely separates monoidal composition in "space" (i.e. on the UI screen), from composition in "time" (i.e. state transitions), which leads to several benefits. It's also a general purpose approach, with Haskell and Purescript implementations available currently, and can be used to build user interfaces for the web or for native platforms.

The biggest advantage of Concur that has emerged is its consistent UI development experience that scales linearly with program complexity. Simple things are easy, complex things are just as complex as the problem itself, no more. Reusing existing widgets, and refactoring existing code is easy and predictable. This means that Concur is suitable for all levels of experience.

1. For Learners - Concur provides a consistent set of tools which can be combined in predictable ways to accomplish any level of functionality. Due to its extremely gentle learning curve, Concur is well suited for learners of functional programming (replacing console applications for learners).
2. For experienced folks - Assuming you are already familiar with functional programming, Concur will provide a satisfying development experience. Concur does not artificially constrain you in any form. You are encouraged to use your FP bag of tricks in predictable ways, and you are never going against the grain. It's a library in spirit, rather than a framework.