Conference Time
Local Time

Pre-Conf Workshop

Wed, Nov 13
Timezone: Asia/Kolkata (IST)
09:30

    Registration - 30 mins

10:00
  • Added to My Schedule
    keyboard_arrow_down
    Bruce Tate

    Bruce Tate - Designing Elixir Systems with OTP

    schedule  10:00 AM - 06:00 PM IST place Meeting Room 1 people 16 Interested add_circle_outline Notify star_halfRate

    You know how to code in Elixir; now learn to think in it. Learn to design libraries with intelligent layers that shape the right data structures, flow from one function into the next, and present the right APIs. Embrace the same OTP that’s kept our telephone systems reliable and fast for over 30 years. Move beyond understanding the OTP functions to knowing what’s happening under the hood, and why that matters. Using that knowledge, instinctively know how to design systems that deliver fast and resilient services to your users, all with an Elixir focus.

    Elixir is gaining mindshare as the programming language you can use to keep your software running forever, even in the face of unexpected errors and an ever-growing need to use more processors. This power comes from an effective programming language, an excellent foundation for concurrency and its inheritance of a battle-tested framework called the OTP.

    If you’re using frameworks like Phoenix or Nerves, you’re already experiencing the features that make Elixir an excellent language for today’s demands. This book shows you how to go beyond simple programming to designing, and that means building the right layers. Embrace those data structures that work best in functional programs and use them to build functions that perform and compose well, layer by layer, across processes. Test your code at the right place using the right techniques. Layer your code into pieces that are easy to understand and heal themselves when errors strike.

    Of all Elixir’s boons, the most important one is that it guides us to design our programs in a way to most benefit from the architecture that they run on. The experts do it and now you can learn to design programs that do the same.

  • Added to My Schedule
    keyboard_arrow_down
    Michael Snoyman

    Michael Snoyman - Applied Haskell Workshop

    schedule  10:00 AM - 06:00 PM IST place Meeting Room 2 people 29 Interested add_circle_outline Notify star_halfRate

    This full day workshop will focus on applying Haskell to normal, everyday programming. We'll be focusing on getting comfortable with common tasks, libraries, and paradigms, including:

    • Understanding strictness, laziness, and evaluation
    • Data structures
    • Structuring applications
    • Concurrency and mutability
    • Library recommendations

    By the end of the workshop, you should feel confident in working on production Haskell codebases. While we obviously cannot cover all topics in Haskell in one day, the goal is to empower attendees with sufficient knowledge to continue developing their Haskell skillset through writing real applications.

Bootcamp Day

Thu, Nov 14
09:30

    Registration - 30 mins

10:00
10:45
11:00
11:30
11:45
12:00
12:40
12:45
13:25
14:00
14:15
15:00
15:20
15:30
15:50
16:25
  • Added to My Schedule
    keyboard_arrow_down
    Anirban Bhattacharjee

    Anirban Bhattacharjee - KPI driven development : Gradual journey from imperative to functional development in JAVA

    schedule  04:25 - 05:10 PM IST place Ball Room 2 people 34 Interested star_halfRate

    Even though there was a delay; but JAVA has been catching up quite nicely when it comes to FP. With frequent releases and feature inclusions at a faster pace, the FP landscape in JAVA is becoming better and better every day. A lot of cutting edge projects(inspired by other languages like clojure, scala, oCaml, haskell, F# etc..) with their high-end/superior APIs complementing the language. The best part is these are just not syntactic sugars; the underlying impact of functional programming(from the language as well as the libraries) when analyzed deeply is extremely enriching and profound. The KPIs which can directly get a face-lift is a lot

    1. Reduced dev/unit-testing effort

    2. Less boilerplate code

    3. Less mutation and higher thread safety

    4. High perf persistent data-structures

    5. Proven performance improvement, reduced allocation and higher throughput

    Developers who have been practicing java/jvm languages for several years will find this really appealing and intriguing.

16:50
17:15

Apply FP

Fri, Nov 15
09:00

    Registration - 30 mins

09:30
10:15

    Welcome Address & Apply FP Day Overview - 15 mins

10:30

    Coffee/Tea Break - 30 mins

11:00
12:00
  • Added to My Schedule
    keyboard_arrow_down
    Tony Morris

    Tony Morris - An Intuition for List Folds

    schedule  12:00 - 12:45 PM IST place Ball Room 2 people 76 Interested star_halfRate

    In this talk, we go back to first principles, defining and examining the definition for a cons list, then take a look at the ubiquitous right and left fold functions on a list.

    The primary focus of this talk is to develop an intuition for how these functions work so that we can best decide when to apply them. Multiple programming languages will be used to help emphasise the independence of the gained intuition. This talk will generally be interactive with the audience as we solve problems and build confidence in our new knowledge.

    Knowing how to apply the various list fold functions is a common question by the student of FP. This talk aims to provide a solid, reliable answer to this question. No prior understanding of list folds is necessary.

  • Added to My Schedule
    keyboard_arrow_down
    Harald Schult Ulriksen

    Harald Schult Ulriksen - From C# monolith to functional actors with Orleans and F#

    schedule  12:00 - 12:45 PM IST place Ball Room 1 people 12 Interested star_halfRate

    This is an experience talk from my work with NRK, the

    Norwegian Broadcasting Company, Norway's public broadcaster.

    Over the last 3-4 years we've taken the TV and radio streaming sites from a monolith to multiple

    domain based services. We'll look at how we've transitioned the from a pure object oriented development team to a function friendly organzation, how gorwing the organization forced us to work with Conways law, as well as a deep dive into the bounded context of personalization.

    Keeping track of user progress and favorite shows is the responsibility of Personalization domain, with high performance requirements and surprisingly

    complex business rules. With new business rules and changing architecture, Personalization was in dire need of work. Combining FSharp and its typesystem and immutability with Orleans, an open source Virtual Actor platform for distributed high-scale computing applications, provided us with functional programming with OO principles in a fast and scalable platform. I'll show why we chose this path, the benefits we gained going from C# to F# and some of the lessons learned building on an actor model.

  • Added to My Schedule
    keyboard_arrow_down
    Yogesh Sajanikar

    Yogesh Sajanikar - Functional Data Structures for Time Series Summary

    schedule  12:00 - 12:45 PM IST place Meeting Room 1 people 40 Interested star_halfRate

    Overview

    IOT is ubiquitous now a days. With time series data pouring in from all possible sources, there is an increasing need to process the data at near real time. However, the transmission, storage and compute cost associated with this data is ever increasing.

    Functional Data Structure for Time Series

    In this talk, we will look at functional implementation of discrete wavelet transforms implemented using Haskell. We will use Haar wavelets for the the demo. The high and low pass filter definition of a wavelet allows a very simple functional implementation of Haar wavelet transform.

    Wavelet Transform

    We will look at simple recursive definition for forward and reverse wavelet transforms. The wavelet transform is very simple to implement in O(N) time complexity using recursive definition, and higher order functions.

    Wavelet as a Container

    Though, these transform functions are good for bulk transform i.e. to convert incoming data to/from wavelet space at once, they are not good for point queries. We will look at how we can partition a wavelet vector in dyadic ranges, and dynamically construct orthonormal basis of the wavelet by directly querying only log N coefficients.

    Wavelet Approximation

    The wavelet container that we constructed can be sparse. i.e. it is possible to prune the coefficients that are not contributing to approximation, and still use the wavelet container.

    Wavelet Sketching

    Sketches are random algorithms to estimate the result with a given accuracy with high probability.

    We can use sum-of-square energy function property to prune the coefficients. Finally we use sublinear AMS sketching algorithm to predict the energy, and prune the coefficients efficiently in log N time rather than O(N) time. This allows us to quickly prune the wavelet container by getting rid of large number of coefficients. This allows very compact representation of the time series data that allows point queries.

    We show Haskell implementation

    • Sketch as a class, and linear properties of Sketch
    • Implementation of AMS using hash functions, and probability distributions
    • Using AMS with hash bucketing to prune wavelet coefficents

    Use Case

    We will look at a historical stock data, and use wavelet transform and sketching to reduce the data size.

    Current Status

    Currently being studied at my organization, such functional application is found to be useful in representing data for quick analytics.

12:45

    Lunch - 75 mins

14:00
  • Added to My Schedule
    keyboard_arrow_down
    Aditya Athalye

    Aditya Athalye - Dr. StrangePipes or: How I learned to stop worrying && "function" in Shell

    schedule  02:00 - 03:30 PM IST place Ball Room 2 people 51 Interested star_halfRate

    What scares the Shell out of people?

    Artefacts of the long and idiosyncratic history of Unix.

    We have so many powerful, stable, widely-available Unix tools and standards, but also plenty of inconsistencies, variants, and arcane caveats; enough to help us... surprise... ourselves in creative new ways. See that cliff you're currently falling off? Yeah, someone went down that road when you were still eating chalk in kindergarten. (Or perhaps you fell off it once before, when I was eating chalk in kindergarten, but it was so long ago that you forgot you've been there done that :-))

    Worse, there's no adult supervision, only user manuals. Within Shell's neon-lit environs, one must learn to tread with care, creativity, and cool calculation.

    One must learn to accept the silent echo as reward for success.

    Why go to Shell at all?

    Several of us already get by just fine with a few memorised spells from Shell. That's not a bad way to live, but we miss out on tremendous everyday value that we can unlock with the Unix way.

    For there exists a vast no-man's land between memorised tricks and large scale "designed" solutions; wherein no single software tool can really solve all the problems we encounter.

    Yet, any modern *nix PC has all one needs to adequately and speedily tailor-make solutions for almost any problem we may encounter in the underserved no man's land.

    Solutions that we can use effectively until we truly hit the kind of scale problems or domain complexity that merit use of specialised tools.

    Unix nature is deeply Functional

    The Unix tools philosophy naturally leads to functional architectures that can scale almost effortlessly. And functional programmers could do worse than learn to exploit such power.

    I'll just leave you with Douglas McIlroy's answer to "Read a file of text, determine the n most frequently used words, and print out a sorted list of those words along with their frequencies.", as seen in More Shell, Less Egg:

    tr -cs A-Za-z '\n' |
    tr A-Z a-z |
    sort |
    uniq -c |
    sort -rn |
    sed ${1}q

    A purely functional, automatically buffered data processing pipeline, built with standard reusable parts, written in 1986, directly usable on today's computers.

    Imaginative Functional Programmers (aren't we all?!) will find striking parallels between the facilities, concepts, and design principles available in their $Langs, and their *nix environments.

    No surprise, because in the dreamy mists of time, the wise hackers of Unix lore, and SmallTalk lore, and APL lore, and Lisp lore, and Forth lore etc... were all different, but they were all together, too.

  • Added to My Schedule
    keyboard_arrow_down
    Anmol Sahoo

    Anmol Sahoo - GADTs in OCaml

    schedule  02:00 - 03:30 PM IST place Ball Room 1 people 37 Interested star_halfRate

    OCaml is a multi-paradigm programming language with a pragmatic mix of functional and imperative programming features. OCaml, which has been around since 1996, has grown to be a battle tested language, widely deployed and used in production systems. In this talk, we will look at the support for Generalized Algebraic Data Types (GADTs), a powerful generalization of the more mundane Algebraic Data Types (ADTs). We will start with an example of building an interpreter for a small language and add type safety through GADTs. We will then look at a few powerful type-safe design patterns that GADTs enable.

  • Added to My Schedule
    keyboard_arrow_down
    Anupam Jain

    Anupam Jain - Supercharged Web Application development with Purescript

    schedule  02:00 - 02:45 PM IST place Meeting Room 1 people 54 Interested star_halfRate

    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.

15:00
15:30

    Coffee/Tea Break - 30 mins

16:00
  • Added to My Schedule
    keyboard_arrow_down
    Harendra Kumar

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

    schedule  04:00 - 04:45 PM IST place Ball Room 2 people 55 Interested star_halfRate

    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.

  • Added to My Schedule
    keyboard_arrow_down
    Saurabh Nanda

    Saurabh Nanda - Getting property-based testing to work after struggling for 3 years

    schedule  04:00 - 04:45 PM IST place Ball Room 1 people 48 Interested star_halfRate

    I got excited about property-based testing after hearing John Hughes talk at Functional Conf 2016. I tried it that year with QuickCheck, but failed miserably (it almost derailed the entire project delivery). I cribbed about it in my talk at Functional Conf 2017. In 2018, Srihari's talk got me excited again. This time, I tried with Hedgehog, and got it to work!

    This talk is about this journey and its learnings. We'll talk about how Hedgehog was used to test [1]:

    • A Postgres backed task/job queue
    • A small Wai/Servant based webapp

    And no, we will not talk about the most common (and completely useless) example of reversing a list!

    [1] Both of these are part of an open-sourced task/job queue library.

  • Added to My Schedule
    keyboard_arrow_down
    Deepak K [Daksh] Gupta

    Deepak K [Daksh] Gupta - Lambdas: The Functional Programming Companion of Modern C++

    schedule  04:00 - 04:45 PM IST place Meeting Room 1 people 18 Interested star_halfRate

    C++ as a Programming Languages had ruled the programming world for quite some time. It was so much synonymous to Object Oriented Programming that when functional programming came into the picture, nobody initially thought of C++ as a candidate for the same.

    Fortunately, the C++ Standardization (isocpp.org) committee had a different idea and they later came up with C++11 which was a paradigm shift in the language. C++ now not only allows programmers to write functional code, but it has also evolved the language into a meta programming language.

    The core of these changes which enables functional programming in C++ revolves around the introduction of Lambdas. Suddenly, with lambdas, we’re not only writing functional code in C++ but can also have functional threads, functional locks, and functional memory management.

    The beauty of lambdas can also be judged from the fact that it has also made many of the STL (Standard Template Library) algorithms functional which, along with the concepts and ideas of Closures makes C++ an ideal candidate to be considered for writing functional codes which includes immutability, Partial function specialization, and pattern matching.

    In this talk, I’ll take you on the journey of functional Programming in modern C++ and how to write awesome and simple C++ code which conforms to all tenets of Functional Programming.

    The talk shall contain full fledged examples which shall be made available to participants post conference

    We’ll also see how the language has evolved and why it’s still a favorite for doing performance intensive jobs which we can, of course, do in a functional way

17:00
  • Added to My Schedule
    keyboard_arrow_down
    Aaron Hsu

    Aaron Hsu - Programming Obesity: A Code Health Epidemic

    schedule  05:00 - 05:45 PM IST place Ball Room people 85 Interested star_halfRate

    Programs are getting fat. They're becoming slow. They're taking up more computing resources. They're getting harder to maintain and more complex from the ground up. Layer upon layer of sophistication is causing us to lose our ability to predict what software will do. Where's that bug? Why is everything going so slowly? Am I even using the right data structures? Where's that important point in the documentation again?

    What's happened to us? In this meta-dive into the nature of our approach to programming, we will explore some of the dangers of our current approaches to programming and the how/why of our current programming obesity problem. We will look at real case studies and see just how bad the situation can be.

    But we will also explore how we can battle these sources of obesity. In this passionate plea for code that we can gain control over again, we will look at examples of how we can return to a state of high-performance on all levels, from code size to code scalability. We will look at the principles that can help us to reach leaner, more efficient, more usable, less buggy code. We will hopefully find some light at the end of the tunnel, and how we can change our outlook on programming to push ourselves towards code that benefits not only ourselves, but also those that will come after us.

17:45

    Closing Talk - 15 mins

Mastering FP

Sat, Nov 16
09:00

    Registration - 30 mins

09:30
  • Added to My Schedule
    keyboard_arrow_down
    Bruce Tate

    Bruce Tate - Joy - Maintaining Passion for Programming

    schedule  09:30 - 10:15 AM IST place Ball Room people 78 Interested star_halfRate

    Many people in our industry are programmers because we're curious and passionate about coding. Each of us can remember latching onto a trivial programming problem and staying with it deep into the night. For far too many of us, that passion for programming fades under the slow, wilting heat of the day to day grind.

    In this talk, Bruce Tate, author of Seven Languages in Seven Weeks, takes a frank look at the grind and offers some practical advice on putting the "fun" back into "functions". We'll introduce some pragmatic ideas to get you excited about the journey again. We can't always dramatically change our circumstances, but we can often make small tweaks to how we approach problems.

    Come along. Enjoy the journey.

10:15

    Welcome Address & Mastering FP Day Overview - 15 mins

10:30

    Coffee/Tea Break - 30 mins

11:00
11:25
12:00
12:45

    Lunch Break - 75 mins

14:00
15:00
15:30

    Coffee/Tea Break - 30 mins

16:00
17:00
17:45

    Closing Talk - 15 mins

Post-Conf Workshop

Sun, Nov 17
09:30

    Registration - 30 mins

10:00
help