GraphQL is a Data Query language, open sourced in July 2015 by Facebook. Extremely growing technology for API driven developments, it was born as a solution to the mobile market problems specifically with target users having 2G/3G bandwidth. later 15+ programming languages made implementation including Erlang for GraphQL. It is an ideal for any application that requires very precise and performant data fetching/manipulation and also it can be hybrid API architecture with Experience based API and Queryable API development. GraphQL allows you to build the client applications based on highly decoupled components without sacrificing performance or over-/under-fetching a data.

This talk presents ‘Introduction to GraphQL - the concepts behind it and how it address common api development challenges such as Over-fetching, Under-fetching, Multiple round trips’. You will learn how you can start application development with GraphQL and Erlang with highly Distributed, Elastic, Asynchronous / Reactive paradigm.

 
14 favorite thumb_down thumb_up 0 comments visibility_off  Remove from Watchlist visibility  Add to Watchlist
 

Outline/structure of the Session

  • What is GraphQL ?
  • What is not GraphQL ?
  • GraphQL v/s REST
  • GraphQL is the better REST
  • Experience based APIs & Queryable APIs
  • How Relational Algebra met REST / JSON APIs
  • Monolithic Microservices | Event Driven Architectural Change | Scaling & Performance
  • Static typing / Type System
  • Arguments
  • Schema Definition types, Query Parsing and Query execution and Type Derivation.
  • Queries and Mutations
  • GraphiQL
  • Reactive Manifesto
  • How Do I do in Erlang ? How does it work.
  • Lesson learnt !

Learning Outcome

Attendee will be able to write new way of Querying Data API with hybrid combination of experience based api and queryable api, talk will helps them to minimize over-fetching, maintenance and reducing lot’s of round trips with GraphQL. Attendee would be able to think solution for highly scalable, elastic, reactive / asynchronous, fault-tolerant monolithic event driven application development. They will be able to write tiny POC (Proof of Concept) with Erlang and GraphQL, this talk will give push up for that.

Target Audience

API Developer, Architect, Functional Programming Enthusiastic, A Programmer

Prerequisite

  • Understanding of JSON / JavaScript.
  • Understanding of Rest / JSON based API standard.
  • Would be good if understanding of Erlang but not necessary.

Ref.

[1] Functional Programming in Erlang https://www.futurelearn.com/courses/functional-programming-erlang

[2] Concurrent Programming in Erlang https://www.futurelearn.com/courses/concurrent-programming-erlang

schedule Submitted 4 months ago

Comments Subscribe to Comments

comment Comment on this Proposal

  • Liked Manuel Chakravarty
    keyboard_arrow_down

    Manuel Chakravarty - Haskell SpriteKit - a Purely Functional API for a Stateful Animation System and Physics Engine

    45 Mins
    Demonstration
    Intermediate

    Graphics, animation, and games programming in Haskell faces a dilemma. We can either use existing frameworks with their highly imperative APIs (such as OpenGL, Cocos2D, or SpriteKit) or we waste a lot of energy trying to re-engineer those rather complex systems from scratch. Or, maybe, we can escape the dilemma. Instead of a Haskell program directly manipulating the mutable object-graph of existing high-level frameworks, we provide an API for purely functional transformations of a Haskell data structure, together with an adaptation layer that transcribes those transformations into edits of the mutable object-graph.

    I this talk, I will explain how I used this approach to architect a Haskell binding to the animation system and physics engine of Apple’s SpriteKit framework. I will discuss both how the binding is structured and how it achieves the translation of Haskell side changes to SpriteKit and vice versa, such that it is sufficiently efficient. Moreover, I will demonstrate by example how to use the Haskell library to implement a simple game.

  • Liked Tamizhvendan S
    keyboard_arrow_down

    Tamizhvendan S - Demystifying Functional Programming

    Tamizhvendan S
    Tamizhvendan S
    Lead Consultant
    Ajira
    schedule 5 months ago
    Sold Out!
    45 Mins
    Talk
    Beginner

    Because of some perceived complexities and the mathematical background in functional programming, the beginners get bogged down while learning and putting it into practice. As a matter of fact, few people give up after some initial attempts. But it is not as much harder as we think. It is just different!

    Together, let's experience a difference perspective of functional programming and get started in a better way 

  • Liked Maria Livia Chiorean
    keyboard_arrow_down

    Maria Livia Chiorean - The path to generic endpoints using Shapeless

    20 Mins
    Talk
    Beginner

    Programming in Scala is sometimes very time consuming. Finding the most efficient way to solve a problem can end up in days of frustration. This talk is a story of trail and error with a twist at the end. It's a story of API endpoints, generic programming, Shapeless and what happens when they all come together. Everything with examples and plenty of code.

  • Liked Ryan Lemmer
    keyboard_arrow_down

    Ryan Lemmer - From Haskell 98 to Modern Haskell - Making sense of the Haskell type system

    45 Mins
    Talk
    Intermediate

    There are several great books and courses that serve as an introduction to functional programming in Haskell. Typically, these introductions focus on the original core of Haskell ("Haskell 98").

    However, going from there into real world Haskell systems can be a bewildering experience. This is because Haskell has evolved significantly since Haskell 98. In this talk we will investigate the key advances in the type-system that make up "modern Haskell".

    • type-system extensions: GADTs, multi-param type-classes, functional dependencies, ...
    • kind-system extensions: type functions, kind polymorphism, type promotion, ...

    By taking a historical perspective we will look at why new language extensions were introduced, and the context in which they first appeared. This approach gives us a layered view of seemingly disparate language features.

    We will see that the evolution of the type system has been a steady march from term-level programming to type-level programming, and ultimately dependently-typed programming in Haskell.

    (This talk will draw from the book "Haskell Design Patterns")