ActiveTasx - A Haskell DSL for building Multi User, Strongly Typed, Flexible Workflows

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.

 
 

Outline/Structure of the Talk

  1. What are workflow systems.
  2. A comparison with existing imperative or graph based workflow systems.
  3. Show examples of surprisingly complex workflow systems built using very simple and easy to understand code.
  4. Discuss details of ActiveTasx implementation.
  5. Demo the Web UI, and automatic persistence.

Learning Outcome

Attendees will gain an understanding of the various ways to tackle the complexities of Workflow management.

They will also understand how one can build pure, functional, declarative DSLs for workflows in Haskell.

Target Audience

Anyone interested in Workflow systems, or Haskell based DSLs

Prerequisites for Attendees

Some prior experience with Functional Programming is desirable.

schedule Submitted 3 months ago

Public Feedback

comment Suggest improvements to the Speaker

  • Liked Mohd Maqbool Alam
    keyboard_arrow_down

    Mohd Maqbool Alam - Building a MySQL Database Driver in Elixir

    45 Mins
    Demonstration
    Intermediate

    Have you ever wondered what happens beneath the covers when you talk to your Database? Well, you are in for a treat! In this talk, we are going to uncover the dark magic behind Database Drivers. We will look at everything that is needed to talk to a database, query its data and transform it into the native data types in Elixir.

  • Liked Anupam Jain
    keyboard_arrow_down

    Anupam Jain - Typesafe Functional SQL

    45 Mins
    Talk
    Intermediate

    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.

  • Liked Harendra Kumar
    keyboard_arrow_down

    Harendra Kumar - Streamly: Declarative Concurrency and Dataflow Programming in Haskell

    Harendra Kumar
    Harendra Kumar
    Founder
    Composewell Technologies
    schedule 3 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    Overview: Streamly is a Haskell library for writing programs in a high level, declarative data flow programming paradigm. It provides a simple API, very close to standard Haskell lists. A program is expressed as a composition of data processing pipes, generally known as streams. Streams can be generated, merged, chained, mapped, zipped, and consumed concurrently – enabling a high level, declarative yet concurrent composition of programs. Programs can be concurrent or non-concurrent without any significant change. Concurrency is auto scaled based on consumption rate. Programmers do not have to be aware of threads, locking or synchronization to write scalable concurrent programs. Streamly provides C like performance, orders of magnitude better compared to existing streaming libraries.

    Motivation: Haskell has a beautiful abstraction capability. Haskell lists, several streaming and concurrency libraries are some examples of good programming abstractions. The problem is that concurrency is not handled elegantly and declaratively by these libraries. Moreover, the lack of good performance gives rise to special purpose performance centric libraries like text and bytestring creating more confusion. Streamly unifies, lists, streaming, concurrency, logic programming and reactive programming with unparalleled performance. We can finally have a unified string handling.

    Audience: Streamly is designed to express the full spectrum of programs. Do not think that if you are writing a small and simple program it may not be for you. It expresses a small program with the same efficiency, simplicity and elegance as a large scale concurrent application. It unifies many different aspects of special purpose libraries into a single yet simple framework. It is especially suitable for high performance and scalable backend data processing systems. If you use or plan to use any real time streaming or data flow programming frameworks including Apache Flink, Apache Spark or asynchronous/reactive programming frameworks like ReactiveX/RxJs then you may be interested in Streamly.

  • Liked Anupam Jain
    keyboard_arrow_down

    Anupam Jain - Supercharged Web Application development with Purescript

    45 Mins
    Workshop
    Beginner

    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.