Using Haskell to build a performant GraphQL to SQL compiler

schedule Dec 14th 04:00 PM - 04:45 PM place Crystal 1 people 12 Interested
  1. Motivation/Problem statement: Lifecycle of a GraphQL query
  2. Design Goals
  3. Why Haskell
  4. Compiler implementation details:
    1. Fast GraphQL parsing with parser combinators
    2. Modelling and manipulating the GraphQL AST with algebraic data types
    3. Software Transactional Memory: Concurrency constructs for scaling GraphQL subscriptions
  5. Summary with performance benchmarks
 
2 favorite thumb_down thumb_up 0 comments visibility_off  Remove from Watchlist visibility  Add to Watchlist
 

Target Audience

Developers interested in using Haskelll or FP in general to solve real-world challenges

Prerequisite

Participants should be familiar with writing basic real-world haskell code.

schedule Submitted 4 months ago

Comments Subscribe to Comments

comment Comment on this Submission

  • Liked Michael Snoyman
    keyboard_arrow_down

    Michael Snoyman - Functional Programming for the Long Haul

    45 Mins
    Keynote
    Beginner

    How do you decide whether a programming language is worth using or not? By necessity, such decisions are usually based on assessments that can be made relatively quickly: the ease of using the language, how productive you feel in the first week, and so on. Unfortunately, this tells us very little about the costs involved in continuing to maintain a project past that initial phase. And in reality, the vast majority of time spent on most projects is spent in those later phases.

    I'm going to claim, based on my own experience and analysis of language features, that functional programming in general, and Haskell in particular, are well suited for improving this long tail of projects. We need languages and programming techniques that allow broad codebase refactorings, significant requirements changes, improving performance in hotspots of the code, and reduced debug time. I believe Haskell checks these boxes.

  • Liked Raghu Ugare
    keyboard_arrow_down

    Raghu Ugare / Vijay Anant - (Why) Should You know Category Theory ?

    45 Mins
    Talk
    Intermediate

    Category Theory has been found to have a vast field of applications not limited to programming alone.

    In this fun-filled talk (Yes! We promise!) , we want to make the audience fall in love with Math & Category Theory in general, and Haskell in particular.

    We will address questions such as below:

    • What is the mysterious link between the abstract mathematical field of Category Theory and the concrete world of real-world Programming ? And why is it relevant especially in Functional Programming?
    • Most of all, how can You benefit knowing Category Theory ? (Examples in Haskell)

  • Liked Tony Morris
    keyboard_arrow_down

    Tony Morris - Parametricity, Functional Programming, Types

    45 Mins
    Talk
    Intermediate

    In this talk, we define the principle of functional programming, then go into
    detail about what becomes possible by following this principle. In particular,
    parametricity (Wadler, 1989) and exploiting types in API design are an essential
    property of productive software teams, especially teams composed of volunteers
    as in open-source. This will be demonstrated.

    Some of our most important programming tools are neglected, often argued away
    under a false compromise. Why then, are functional programming and associated
    consequences such as parametricity so casually disregarded? Are they truly so
    unimportant? In this talk, these questions are answered thoroughly and without
    compromise.

    We will define the principle of functional programming, then go into
    detail about common problems to all of software development. We will build the
    case from ground up and finish with detailed practical demonstration of a
    solution to these problems. The audience should expect to walk away with a
    principled understanding and vocabulary of why functional programming and
    associated techniques have become necessary to software development.

  • Liked Harendra Kumar
    keyboard_arrow_down

    Harendra Kumar - High Performance Haskell

    45 Mins
    Talk
    Intermediate

    Haskell can and does perform as well as C, sometimes even better. However,
    writing high performance software in Haskell is often challenging especially
    because performance is sensitive to strictness, inlining and specialization.
    This talk focuses on how to write high performance code using Haskell. It is
    derived from practical experience writing high performance Haskell libraries. We
    will go over some of the experiences from optimizing the "unicode-transforms"
    library whose performance rivals the best C library for unicode normalization.
    From more recent past, we will go over some learnings from optimizing and
    benchmarking "streamly", a high performance concurrent streaming library. We
    will discuss systematic approach towards performances improvement, pitfalls and
    the tools of the trade.

  • Liked George Wilson
    keyboard_arrow_down

    George Wilson - Laws!

    45 Mins
    Talk
    Beginner

    Laws, laws, laws. It seems as though whenever we learn about a new abstraction in functional programming, we hear about its associated laws. Laws come up when we learn about type classes like Functors, Monoids, Monads, and more! Usually laws are mentioned and swiftly brushed past as we move on to examples and applications of whatever structure we're learning about. But not today.

    In this talk, we'll learn about Functors and Monoids, paying close attention to their laws. Why should our abstractions have laws? We'll answer this question both by seeing powers we gain by having laws, and by seeing tragedies that can befall us without laws.

  • Liked Stavros Aronis
    keyboard_arrow_down

    Stavros Aronis - Conquering race conditions in Erlang programs with Concuerror

    45 Mins
    Demonstration
    Intermediate

    Concurrency-related bugs, such as race conditions and deadlocks, are some of the hardest bugs to isolate, reproduce, understand and fix. Even Erlang programs can suffer from such bugs, for example when messages arrive in unexpected orders or shared resources (e.g. ETS tables) are accessed concurrently. In this workshop I will demonstrate how developers of all levels can use Concuerror, a testing and verification tool for Erlang programs, to automatically detect, isolate and understand concurrency-related errors in their code and explain how the tool can ultimately prove the absence of such errors. I'll also share experiences from two industrial applications of Concuerror in verifying interesting aspects of distributed algorithms.

  • Liked Tony Morris
    keyboard_arrow_down

    Tony Morris - Let's Lens

    Tony Morris
    Tony Morris
    Sr. Software Engineer
    Queensland FP Lab, Data61
    schedule 4 months ago
    Sold Out!
    480 Mins
    Workshop
    Intermediate

    Let's Lens presents a series of exercises, in a similar format to the Data61 functional programming course material. The subject of the exercises is around the concept of lenses, initially proposed by Foster et al., to solve the view-update problem of relational databases.

    The theories around lenses have been advanced significantly in recent years, resulting in a library, implemented in Haskell, called lens.

    This workshop will take you through the basic definition of the lens data structure and its related structures such as traversals and prisms. Following this we implement some of the low-level lens library, then go on to discuss and solve a practical problem that uses all of these structures.

  • Liked Stavros Aronis
    keyboard_arrow_down

    Stavros Aronis - Welcome to the Erlang Ecosystem

    180 Mins
    Tutorial
    Beginner

    "Are there really companies that use Erlang?" is the most common (and by now expected) question I have been asked by my peers ever since I joined the Erlang Solutions office in Stockholm, not too long ago. "Why?" is, naturally, the second question. In this introductory workshop I will explain what are the key ideas that Erlang is built upon, how these ideas have evolved into a powerful set of design patterns that compose the Erlang/OTP framework and why these ideas and patterns are useful to plenty of industries that use Erlang (and not merely to telecom!). I will also introduce the language ecosystem that has evolved around Erlang, including languages such as Elixir, LFE, and Alpaca.

  • Liked Ravi Mohan
    keyboard_arrow_down

    Ravi Mohan - Experience Report: Building Shin - A Typed Functional Compiler For Computational Linear Algebra Problems.

    Ravi Mohan
    Ravi Mohan
    CEO
    AxiomChoice
    schedule 6 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    Abstract: I wrote a distributed (mostly) Functional Compiler in Scheme, OCaml and Elixir that incorporates knowledge of Computational Linear Algebra and domain specific knowledge to generate highly optimized linear algebra code from specification of problems. This talk is about lessons learned in the process.

    The problem:
    In every domain that uses computational linear algebra (which is all of engineering and science), we encounter the 'how to optimize a linear algebra expression into an optimized sequence of BLAS (or LAPACK or $linear_algera library) kernel calls' problem.

    Example: (if the math equations make you want to tear your hair out and go jump off a cliff, don't worry, it is just an example, you don't have to grok it. Just skim the equations The basic problem being addressed here is that solving such equations with code takes up a lot of effort and time from experts in computational linear algebra)


    Here is a linear algebra expression from a genetics problem , specifically GWAS -Genome Wide Association Studies, looking for significant associations for millions of genetic markers- where the essence of the problem [1] comes down to generating the most efficient algorithm possible that solves these equations

    This in turn involves solving a 2 dimensional sequence of Generalized Least Squared Problems of the form

    The algorithms to solve these can be directly coded up in Matlab or Julia. But there are problems with this approach, with this specific problem.


    1. For different input sizes, different algorithms give the most optimal performance. Which algorithm do you code up?


    2. Even for a given input size, there are multiple algorithms that compute the same result, but have differing computational characteristics depending on the hardware etc. How do you generate the optimal algorithm for your hardware ?


    3. Most importantly the structure of *this* specific problem allows optimizations that are specific to the problem which are not built into generic linear algebra routines. (Obviously, one can't expect MATLAB to incorporate problem specific information for every scientific/engineering problem ever). The GLS problems are connected to others, thus saving intermediate results can save hours of computation vs calculating every GLS problem from scratch

    In practice, one needs to be an expert in Computational Linear Algebra to come up with the optimized algorithm for a domain specific problem, and then write (say Fortran) code to use BLAS, LAPACK etc optimally to actualize this algorithm, often with much iteration, often consuming 100s of hours.

    The Solution:


    Incorporating this 'expert knowledge' into a compiler speeds up the time taken to arrive at the best solution (often by a factor of 100 or 1000), and allows Computational Linear Algebra experts to do more interesting things, like focus on their research.

    For this particular problem, the above equations, and additional knowledge of the problem domain are the input into an expression compiler. The output is highly efficient and 'proved correct' code

    In compiler terms, incorporating domain knowldege into the compilation process results in being able to apply optimizations to the generated Syntax Trees/Graphs, resulting in optimal algorithms. (note: the output of the compiler is a program in another language- say Matlab).

    In essence, "Domain Specific Compilers" consume knowledge about the structure of a problem and generate optimized code that solves that problem.

    Shin is one such compiler. It consumes a problem description and outputs highly efficient Julia code that solves the problem.

    This talk focuses on the engineering challenges I faced in building this compiler, with a special focus on the approaches that failed [5]

    Trivia:

    "Shin" is the Hebrew letter, not the English word meaning 'front of the leg between knee and ankle' ;-).

    Every company uses names from a common theme to name their servers and components - Athena, Zeus, Hercules , or Thor, Loki, Odin, or Jedi, Sith, Skywalker etc. We use Hebrew words, so we have Ruach, Melekh, Malkuth etc..

  • Liked Andrew McCluskey
    keyboard_arrow_down

    Andrew McCluskey - Property-based State Machine Testing

    45 Mins
    Talk
    Intermediate

    Automated testing is key to ensuring the ongoing health and well-being of any software project,giving developers and users confidence that their software works as intended. Property based testing is a significant step forward compared to traditional unit tests, exercising code with randomly generated inputs to ensure that key properties hold. However, both of these techniques tend to be used at the level of individual functions. Many important properties of an application only appear at a higher level, and depend on the state of the application under test. The Haskell library hedgehog, a relative newcomer to the property based testing world, includes facilities for property-based state machine testing, giving developers a foundation on which to build these more complicated tests.

    In this talk, Andrew will give you an introduction to state machine property testing using hedgehog. He'll start with a quick refresher on property based testing, followed by a brief introduction to state machines and the sorts of applications they can be used to model. From there, he'll take you on a guided tour of hedgehog's state machine testing facilities. Finally, Andrew will present a series of examples to show off what you can do and hopefully give you enough ideas to start applying this tool to your own projects. The first set of examples will test a web application written in Haskell. These tests will include: content creation and deletion, uniqueness constraints, authentication, and concurrent transactions. A second set of examples will test an application written in a language other than Haskell to demonstrate that this technique is not limited to applications written in Haskell.

    An intermediate knowledge of Haskell and familiarity with property based testing will be beneficial,but not essential. The slides and demo application will be available after the talk for people to study in detail.

  • Liked Ram Dayal Vaishnav
    keyboard_arrow_down

    Ram Dayal Vaishnav - WebVR for creating immersive Virtual Reality experience

    Ram Dayal Vaishnav
    Ram Dayal Vaishnav
    Sr. Software Engineer
    Arcesium
    schedule 7 months ago
    Sold Out!
    45 Mins
    Demonstration
    Beginner

    Have you noticed that the development of Virtual Reality experiences has started a major makeover of the computer industry? I believe that Virtual Reality is going to become a primary platform soon, which will completely change the way we work, play and communicate digitally. The Web, being the most open platform, is now a key participant for providing cool Virtual Reality experiences. I would love to talk about Building Virtual Reality websites using A-Frame in this version of FunctionalConf.

    A-Frame is an open-source web framework by Mozilla for easily creating VR experiences using WebVR which work on all platforms. In this session, audience will learn to use various concepts & APIs of A-Frame through demos and live coding few WebVR scenes. With this, you will be able to create interactive and immersive VR websites on the web. A-Frame has incorporated functional programming in various ways, one such implementation was discussed in https://github.com/aframevr/aframe/issues/2012. I will talk about few of these functional programming related aspects related to A-Frame.

    This session will also cover following:

    - How A-Frame is different from ReactVR
    - Keys to make your VR website to have immersive experience
    - How can one get involved with the A-Frame community to contribute in its development.
    - Step by step example towards how a piece of code can be shifted towards being functional in A-Frame.

  • Liked Ankit Rokde
    keyboard_arrow_down

    Ankit Rokde - My Haskell Program does not fail. Proof?

    Ankit Rokde
    Ankit Rokde
    Student
    IIT Bombay
    schedule 5 months ago
    Sold Out!
    20 Mins
    Talk
    Intermediate

    Proving correctness of programs and ensuring they are bug-free has always been a challenging problem.

    Mostly we have relied on manual testing to check the correctness of programs.

    Strong static type systems help us to write bug free programs from the start but many interesting cases can miss out.

    Many tools such as QuickCheck, Liquid Haskell have been developed to address this issue.

    In this talk, we will presenting a different approach, Bounded Model Checking (BMC), which has been very successful in proving correctness of imperative programs by means of tools such as CBMC.

    We will explain how BMC works at high level, how we have adopted it for Haskell and our success with the same.

    We will also present how you can use it to prove correctness of your Haskell programs.

  • Liked Aloïs Cochard
    keyboard_arrow_down

    Aloïs Cochard - The Magnum Opus

    45 Mins
    Talk
    Beginner

    From Ancient Egypt to the Middle Ages humanity lost it's way in the quest to find the philosopher's stone.

    While following the recent advance in machine learning one might think that we are running in that same quest again,
    only differences this time are that our philosopher's stone is deep learning and the promise is general artificial intelligence instead of immortality.

    The current machine learning ecosystem is mainly based on python and pretty much feels like alchemy,
    lot of trial and errors, lack of tooling and good engineering practices, ...

    Let's take a tour of the current ecosystem and see how can we do better and safer high performance machine learning using Haskell!