Pre-Conf Workshop

Thu, Nov 16
Timezone: Asia/Kolkata (IST)

    Registration - 30 mins

  • Added to My Schedule
    Kostis Sagonas

    Kostis Sagonas - A PropEr Tutorial on Property-Based Testing

    schedule  02:00 - 06:00 PM place Studio 4 people 7 Interested add_circle_outline Notify star_halfRate

    Property-based testing is a novel approach to software testing, where the tester needs only specify the generic structure of valid inputs for the program under test, plus certain properties that the program is expected to satisfy for every valid input. PropEr is an open-source tool for property-based testing in Erlang. One of its salient features is that it provides a tight integration of the language of types and specs of Erlang with property-based testing. Any type can be used as a generator and any function specification can be directly used as a simple property of a function. In addition, PropEr comes with components for testing stateful applications and for targeted property-based testing.

    This hands-on tutorial will introduce through examples the support that PropEr provides for property-based testing in Erlang, present representative examples of its use, and will give advice for the proper use of the tool.

Erlang & Elixir Factory Lite

Fri, Nov 17
Timezone: Asia/Kolkata (IST)

    Registration - 30 mins


    Welcome Address - 15 mins


    Coffee/Tea Break - 15 mins


    Lunch - 60 mins


    Coffee/Tea Break - 15 mins

  • Added to My Schedule
    Cameron Price

    Cameron Price - Making it Fast: The Power of Benchmarking

    schedule  04:00 - 04:45 PM place Edinburgh people 7 Interested star_halfRate

    There's an old expression, usually attributed to Kent Beck, that we should "Make it work, make it right, make it fast", in that order. This talk is going to focus on making it fast.

    Not long ago, I was working on a little problem in Elixir that involved a two dimensional array. Now, Elixir doesn't really have arrays, it has lists, maps, tuples, and binaries, so the one thing we can be sure about when implementing a 2-d array is that we're going to be simulating it using something else. What I discovered was surprising, and served as an important lesson about actually benchmarking things.

    In this talk, we'll discuss the importance of benchmarking, demonstrate some tools that make benchmarking in Elixir very simple, and show you some surprising results about which approaches are faster in this language.

  • Added to My Schedule
    Ravi Mohan

    Ravi Mohan - Predator: A Framework for Developing Programmatic Players for Complex Board Games

    schedule  04:00 - 04:45 PM place Regal people 13 Interested star_halfRate

    Summary: An Experience Report on How a very time constrained Haskeller learned Erlang and PureScript "in small pieces" to create programmatic opponents aka 'bots' for complex boardgames

    Every experience report tells a story - the story of a project, unvarnished and without artifice, programmer to programmer, out of the sight and hearing of the manager folks, often involving one or more of comedy, tragedy, farce etc. This report is no exception.

    I have a fulltime 'dayjob' and my standard 'language toolkit' is Haskell + C + Lua. My co-founder is a bit of an Erlang maniac, and challenged me to learn Erlang and actually building something in it and *then* go on about the superiority of Haskell.

    This is the story of my response to the challenge and how I learned and coded Erlang/Elixir in very small chunks of time (about 10 - 20 )minutes a day max) and attacked an interesting problem. This severe time constraint (and lack of any previous knowledge of Erlang) shaped the nature of the (still evolving) system.

    The problem:

    The number of boardgames that you can whip out at a gathering and expect people to want play is very small.. Monopoly, Snakes and Ladders, and maybe, if you are *very* lucky, Settlers of Catan. And that's about it.

    Getting people to play these games is relatively easy.

    However the world of boardgames is *much* wider.

    There are literally tens of thousands of boardgames that simulate everything from very abstract geometry puzzles to ones that simulate complex economies and political situations.

    Some of the latter are used in very unexpected ways, e.g to train spies and military officers.

    Here is an example of an interesting game.

    A Distant Plain (by GMT Games) is a boardgame for 4 players that put them in the roles of the US military forces, the Afghan government, the Taliban, and Warlords/drug dealers, all competing for power in Afghanistan.



    Here is another
    The War of the Ring, a game for 2 players.

    "In War of the Ring, one player takes control of the Free Peoples (FP), the other player controls Shadow Armies (SA). Initially, the Free People Nations are reluctant to take arms against Sauron, so they must be attacked by Sauron or persuaded by Gandalf or other Companions, before they start to fight properly ...."


    And one more

    "The battle of Sekigahara, fought in 1600 at a crossroads in Japan, unified that nation under the Tokugawa family for more than 250 years.

    Sekigahara allows you to re-contest that war as Ishida Mitsunari, defender of a child heir, or Tokugawa Ieyasu, Japan's most powerful daimyo (feudal lord)."


    What these games have in common
    1. They are wonderful games, immersing you into their respective worlds.
    2. They have (relative to Snakes and Ladders or Monopoly) complex rulesets, which take effort and time to master.
    3. They are rarely played in India.
    4. Even when people own them, opponents are almost impossible to find and schedule.

    Which means that if you own these games and live in India, getting to actually play these games is close to impossible.

    Which is a problem.

    The (incomplete, but ongoing) solution

    Being a programmer, I solve this problem by writing programmatic opponents (aka 'bots') to take the place of other players. This involves all kinds of interesting sub problems - game representation, logic processing for rules, building AI 'smarts' for your opponents, gui and event handling etc.

    Since I am doing this in my non existent spare time, and this being a response to an Erlang user's challenge, I learned (am sill learning) Erlang and Elixir (and some minimal PureScript), and built ( am still building) the system at the same time..

    This talk is about the many challenges I faced in building automated game players (and extracting common frameworks/libraries) from them, while simultaneously learning two FP languages.

    Since this is an experience report, it is basically a highly subjective list of lessons learned, victories *and defeats*, what worked *and more importantly what didn't work*.

    If you can't use FP at work, but are considering doing so on a personal project, or want to learn how to get going on an FP learning effort, you might benefit from my experience - both successes and failures. I also talk about how to go about learning Erlang/Elixir in the shortest possible time.


    Reception Dinner - 135 mins

Functional Conf

Sat, Nov 18
Timezone: Asia/Kolkata (IST)

    Registration - 30 mins


    Welcome Address - 15 mins


    Coffee/Tea Break - 15 mins

  • Added to My Schedule
    Tony Morris

    Tony Morris - Functional Programming in Aviation

    schedule  11:30 AM - 12:15 PM place Edinburgh people 9 Interested star_halfRate

    In this talk & demo, we have a look at some of the low-hanging problems in general aviation and how functional programming can be applied to provide significant improvements in efficiency and air safety. The current solutions to problems such as navigation, traffic/terrain collision avoidance and weight/balance calculations will be demonstrated to the audience, mostly for amusement. More seriously, we will have a look at the legacy that has led to the way things are, and how to improve by applying our programming skills.

    We will look at:

    • how aviation safety is regulated.
    • how aeronautical services are provided to flight operators.
    • how aeronautical navigation is conducted and regulated.
    • how the weight and balance for a flight is conducted.
    • the methods by which aircraft and ground coordinate between each other.

    We will see:

    • some real (and basic) data management problems in aviation, that very obviously threaten safety, then solve them, using programming.
    • we will see a live demonstration of aeronautical navigation methods, investigate incident reports where lives were lost as a result, and consider how our programming skills can yield improvements, possibly even save lives.
    • we will conduct a real weight&balance calculation for a flight, then once hilarity inevitably ensues, we will look at the problems that arise by this method, then solve them using data structures and functional programming. Some
      of these practical problems are obvious, even to a non-aviator, and the predictable incident reports are the end result.
    • finally, we will have a look at a live demonstration of a software defined radio (SDR), receiving ADS-B transmissions from aircraft (live), an AHRS implementation and GNSS receiver using off-the-shelf, low-cost parts. We will look at why these instruments are helpful to aircraft pilots and interact with that device using the Haskell programming language.
  • schedule  11:30 AM - 12:15 PM place Studio 4 people 9 Interested star_halfRate

    Git is one of the most popular tool for a developper and a part of the power of Git is come from some functional concepts. So, it's obvious to implement the Git format with OCaml!

    This talk will present the functionnal concepts of Git (like the immutable tree) and show a practical implementation with OCaml step by step. Then, we will explain how can scale an OCaml code to compute a huge Git repository and understand by this way the power of OCaml (and the mix between the functionnal and the imperative way).

    At the end, we will show an example of the usability of Git with OCaml with a concrete application.

  • schedule  11:30 AM - 12:15 PM place Regal people 21 Interested star_halfRate

    Using a programming language that supports first class functional programming doesn’t necessarily imply that the code you write is functional. Functional programming has the nice properties of being compositional - you design smaller abstractions and then reuse them to build larger ones. You use the power of algebraic properties that these abstractions offer to build larger elements of your model out of smaller ones.

    However often we find that many code bases designed in a functional programming language are inherently imperative, especially when you are using a multi-paradigm language like Scala or Java. There’s nothing wrong with imperative code, but it lacks the niceties of expression based composition that makes reasoning about your code so much easier. Also assignments used in imperative code are inherent side-effects that are best avoided (or at least minimized) in an expression oriented language.

    In this session I will discuss some of my experiences of mining imperative code and refactoring them into functional patterns. You will be surprised to see how much functional goodness can be derived through functional thinking. Algebraic structures like Monoids, Monads and Kleislis are just buried within the reams of imperative statements crying to come out. In an exercise of half an hour we will liberate them and see how the code quality improves from the point of view of modularity, compositionality and simplicity.

    The slides of the talk has been uploaded at


    Lunch - 45 mins

  • Added to My Schedule
    Rahul Muttineni

    Rahul Muttineni - Eta Fibers: Towards Better Concurrency on the JVM

    schedule  02:00 - 02:45 PM place Edinburgh people 12 Interested star_halfRate

    In order to handle modern, real-time demands, companies are moving to reactive microservice architectures. These architectures are much more flexible but must be programmed asynchronously to minimize latency and handle as many concurrent requests as possible. However, asynchronous programs are hard to read, maintain, and debug. We solve this in Eta with Fibers.

    Eta is a pure, lazy, statically-typed language on the JVM that gives you the power of Haskell on the JVM. By definition, Eta is well-designed to handle the problems of concurrent & distributed systems with abstractions that are simple to use and reason about.

    One of these abstractions is the concept of Fibers which are lightweight, cooperative, and non-blocking threads that allow you to handle concurrency with ease. This contrasts with green threads, which are pre-emptive and cannot be controlled in a fine-grained manner by the developer. Moreover, we have developed a sequenceable (monadic) API for Fibers to unify asynchronous and synchronous code, solving the notorious "callback hell" problem.

  • Added to My Schedule
    Aaron W Hsu

    Aaron W Hsu - Design Patterns vs. Anti-pattern in APL

    schedule  02:00 - 02:45 PM place Studio 4 people 14 Interested star_halfRate

    APL is a notorious language with a reputation for being "write only" and difficult to learn. Yet, many people consider APL to be their single most productive, advantageous tool that they hope never to give up. In particular, it is generally observed that many computer scientists have a poor opinion of the usability of APL, while many data scientists and domain experts find the language to be exceptionally usable.

    This session focuses on the experienced programmer's struggle to gain real facility with APL beyond the basic, trivial understanding of its semantics and syntax (which can be taught in a few hours). We will observe this struggle through a "human-centered" experience analysis identifying a set of Pattern/Anti-pattern tensions that are at the heart of the intermediate APL learning "wall." By examining the experience of thinking and working with APL code versus regular code, we can identify principles of APL coding practice that directly oppose the widely taught and embraced best practices of the broader programming community. We'll see not only what these principles are, but also why they survive in APL and how they contribute to the positive development cycle of an experienced APL programmer, instead of the negative impact such practices usually have when writing in other languages.

    Understanding these practices will provide a focus point for the discussion of programming experience design and the use of concise array language, as well as provide a structure for becoming better able to write, read, and think in APL expert.

  • schedule  02:00 - 02:45 PM place Regal people 15 Interested star_halfRate

    Service Discovery is an important aspect of microservices, particularly when using containers on elastic infrastructure. Most popular approaches for service discovery require a standalone fault tolerant cluster like Consul, Zookeeper or etcd.

    If you are already using Akka as a clustering platform for your services, there is an interesting alternative available for Service Discovery. CRDTs, or Conflict-free Replicated Data Types are a relatively new primitive in distributed systems. CRDTs allows concurrent updates without coordination and has provisions for tuning consistency levels. 'Distributed Data' extension natively supports CRDTs on top of Akka-Cluster.

    We used CRDTs in Akka to build the service registration and discovery mechanism for TMT's (Thirty Meter Telescope) software platform. TMT will be world's largest optical telescope once operational. The ongoing software work is open source and available on github. We would like to share the details of our implementation and also compare it existing approaches.


    Coffee/Tea Break - 15 mins

  • Added to My Schedule
    Vimal Kumar

    Vimal Kumar - Lessons Learned using PureScript to build Mobile App Development Framework

    schedule  03:00 - 03:45 PM place Edinburgh people 6 Interested star_halfRate

    Transactional apps are nothing but simple conversational flows between the User and System. They can be written using a simple UX DSL leveraging continuation passing style (CSP) semantics. Despite this being the most important problem to simplify, we find that the current frameworks complicate the building and maintenance of transactional apps, requiring heavy investment in engineering effort and the development process is not a pleasant creative experience.

    At Juspay, we saw no reason for this to be the case, and set out to create a framework to dramatically lower the barriers of entry for quickly building out solutions to typical real world applications. Being strong believers in the functional programming paradigm, we abstracted out all the parts of an app as extremely composable lego blocks / pure functions.

    We chose PureScript as our core language, for the conciseness of Haskell paired with the ubiquity of the JavaScript interpreter. The UI components and business flows are simple pure functions that are reusable across apps. The frontend and backend are unified, represented as a continuation of flow between the client and server.

    In the last several months, we have made major strides towards allowing everyone in our company to be able to examine and write the code of the apps we are building -- from fresher to product manager to designer. We have trained around 100 interns on Haskell and PureScript to work on our platform in production. We have been able to deploy this framework into production in serious payment and banking systems.

    In this talk, we will share our experience with PureScript. We will also dig deeper into how PureScript and a free monadic DSL helped us achieve our goal.

  • schedule  03:00 - 03:45 PM place Studio 4 people 11 Interested star_halfRate

    In Indian classical music, we have Jugalbandi, where two lead musicians or vocalist engage in a playful competition. There is jugalbandi between Flutist and a Percussionist (say using Tabla as the instrument). Compositions rendered by flutist will be heard by the percussionist and will replay the same notes, but now on Tabla and vice-versa is also possible.

    In a similar way, we will perform Code Jugalbandi to see how the solution looks using different programming languages and paradigms.This time the focus of code jugalbandi will be on solutioning in different paradigms - object-oriented or functional programming and array-oriented paradigms.

    During the session, Morten and Dhaval will take turns at coding the same problem using different languages and paradigms. There would be multiple such rounds during the Jugalbandi.

  • Added to My Schedule
    Riccardo Terrell

    Riccardo Terrell - Taming and Composing high performance Stream-Oriented Processing Systems for Big Data

    schedule  03:00 - 03:45 PM place Regal people 13 Interested star_halfRate

    Real time applications are dominating the industry! Data is the main ingredient in Internet-based, social media and Internet of things (IoT) systems, which generate continuous streams of events used for real time analytics. This poses a tremendous challenge due to the massive volume of data collected and processed. These event-based Real-time analysis systems can easily process millions of messages per second through new generation solutions by simply defining small flows and then combining them together to create processing graphs. In this talk, will cover the concepts behind high-performance streamed-oriented big data processing systems. We will explore messaging queue systems like Kafka and Akka Streams which let developers define their process workflows at a higher level to define a graph system enabling a high throughput. You will learn how to integrate high performance stream message queues and how to define process workflows in C# and F#.


    Closing Talk - 15 mins

Post-Conf Workshop

Sun, Nov 19
Timezone: Asia/Kolkata (IST)

    Registration - 30 mins

  • Added to My Schedule
    Manuel Chakravarty

    Manuel Chakravarty - Functional Programming in Swift

    schedule  10:00 AM - 06:00 PM place Studio 1 people 6 Interested add_circle_outline Notify star_halfRate

    Swift’s strong functional programming support generates a lot of interest in adapting functional programming techniques to improve designing, developing, and maintaining Cocoa applications. This workshop will help you unlock this potential.

    We will explore the foundations of functional programming and how functional programming helps to improve software development. We will start by discussing the main goals of functional programming, followed by surveying Swift’s language features that support functional programming. Then, we will look at how to put functional programming principles into practice using Swift. We will focus on immutable data structures, value types, and functional reactive programming.

    = Value types

    One of the biggest changes in the transition from Objective-C to Swift is the new type system. This change is at the heart of Swift’s language design, from optionals over value types to constrained generics, and to truly understand the language, a thorough understanding of its type system is indispensable. We will survey these type system features with special attention to value types. We will discuss how structs and enums in Swift can be used to help avoid bugs by design and how immutable data structures help to avoid unwelcome side effects.

    = Functional reactive programming

    Functional reactive programming (FRP) promises to replace unstructured side effects by structured change propagation in response to user input, network events, sensor activity, and similar. Typically explained by way of sophisticated, but often also complex functional reactive programming frameworks, such as ReactiveCocoa and RxSwift, it can be difficult to see the simple principles underlying functional reactive programming. In fact, these principles are sufficiently simple that we can explain them by building a functional reactive programming library from scratch.

    We will discuss how we can construct our own lightweight functional reactive programming library out of simple components using Swift’s support for protocol-oriented programming. Moreover, we will discuss how to use this library to design and implement the change propagation between the model and view components of a Cocoa app.

    All of this is illustrated with hands-on coding exercises based on simple iPhone application that incorporates the discussed techniques.

  • Added to My Schedule
    Ryan Lemmer

    Ryan Lemmer - Haskell Design Patterns

    schedule  10:00 AM - 06:00 PM place Studio 2 people 24 Interested add_circle_outline Notify star_halfRate

    This is an experiential workshop, we will code together, and explore ideas from first principles. You will need GHC 8.*

    The workshop is pitched at Haskell enthusiasts (you don't have to be hardcore at Haskell, I am not!). We'll be writing code together and apart, reflecting on code and ideas, and getting into and out of trouble.

    Patterns for IO

    Experience the 3 styles of IO programming in Haskell, in the order in which they evolved:

    * imperative style (the status quo)
    * Lazy IO and its limitations
    * Iteratee IO, the solution to Lazy IO

    As we compare the different styles, we will pay attention to

    * what controls evaluation
    * space and resource management
    * the relationship between producer and consumer

    From Foldable, Traversable to Lenses

    We follow the evolution of fold and map on lists, to their generalisation over arbitrary types with the Foldable and Traversable type-classes.

    The Lens library raises Foldable and Traversable to an even higher level of abstraction. We will see how the Lens library gives a unified vocabulary for traversal of arbitrary data structures.

    Functor, Applicative, Arrow, Monad

    These data types fall on a spectrum of power and generality (Functor being the most general, and Monad the most powerful). By experiencing how these types differ in the way they compose, we can gain a clearer understanding of where and how each type may be used.

    Dependent Haskell / Type-level programming 101 (bonus material)

    In modern Haskell, the line between types and functions have blurred, types have become as powerful and expressive as functions. Since we can write functions on type-level, we can do whatever we like with types! Almost.

    Let's write some type-level code, and see why Dependently Typed Programming matters.

    Datatype Generic Programming (bonus material)

    This style of Haskell programming is based on a simple technique: instead of defining functions for ad-hoc types, we deconstruct our types into a more fundamental type representation, and then write generic functions against the lower-level type. These generic functions are impervious to changes in the original, higher-level data types.

    We will experience datatype generic programming from first principles, and along the way uncover the key ingredient in the magic sauce called GHC.Generics.

  • Added to My Schedule
    Martin Thompson

    Martin Thompson - High-Performance Messaging with Aeron

    schedule  10:00 AM - 06:00 PM place Studio 3 people 23 Interested add_circle_outline Notify star_halfRate

    In this workshop you will learn how to build microservices with Aeron and SBE in Java. Microservices capable of handling millions of messages per second with very low and predictable response times. We will cover some networking theory and the design of Aeron so you know how to use it with mechanical sympathy.

    The core design of Aeron uses a new functional data structure and functional concepts. In this workshop we will explore how functional designs applied with mechanical sympathy can result in the highest performance messaging system available.

  • Added to My Schedule
    Robert Virding

    Robert Virding - Deep Dive into Erlang Ecosystem

    schedule  10:00 AM - 06:00 PM place Studio 4 people 11 Interested add_circle_outline Notify star_halfRate

    Full day hands-on workshop on building concurrent, fault-tolerant and scalable systems in Erlang/OTP in the Erlang Ecosystem. We will look at three languages in the Ecosystem, Erlang, Elixir and LFE, and show how they can all be used together when building systems.

  • schedule  10:00 AM - 06:00 PM place Studio 5 people 4 Interested add_circle_outline Notify star_halfRate

    Become the master of the multicore domain. Learn how to harness the powers of parallel computation and multicore computation to dominate peer applications in finance software, video games, web applications and market analysis. To yield the most performance, computer programmers have to partition and divide computations to maximize the performance while taking full advantage of multicore processors. Start your path from Padawan to Jedi, after this workshop you will be ready to return to work and have code bend to your will. This course will introduce you to technologies and tools available to developers at every level who are interested in achieving exceptional performance in applications.

    You will gain an insight into the best practices necessary to build concurrent and scalable programs in .NET using the functional paradigm, which covers OnPrem and Cloud based applications.