Pre-Conf Workshop

Thu, Nov 16
09:30

    Registration - 30 mins

10:00
  • Added to My Schedule
    keyboard_arrow_down
    Aaron W Hsu

    Aaron W Hsu - Functional Array Funhouse Intensive

    schedule 10:00 AM - 06:00 PM place Sigma Hall 1 people 7 Attending shopping_cart Reserve Your Seat

    How would your make your programs easier to write, inherently parallel, and have high performance across GPUs and CPUs? How about a development methodology that makes agile programming look sluggish and unreliable? How about shrinking the size and complexity of your code base by an order of magnitude, while increasing performance by an order of magnitude? This intensive workshop is designed to demystify the strange and special world of array programming like you may never have seen it before. Iverson-style array programming terrifies some and amazes others, but no one can argue with the results in areas such as finance, energy, education, or medical research. New research has made array programming scalable across a wide array of parallel hardware architectures. Often renowned for remarkably short, concise code that does a tremendous amount, the area of production level, array programming is an often misunderstood area. This workshop will bring you through a whirlwind of array programming concepts by example and case study, opening up the curtains on the original interactive functional programming language in its modern incarnation. You will learn how you can make use of this sometimes mystical world, with an emphasis on the concepts and how to integrate these concepts into a practical, targeted development methodology and ecosystem for maximizing productivity and leveraging the benefits of notational thinking to their full effect. The goal is to let you keep the magic and fun of programming alive while you use that magic for your benefit in the real world.

  • Added to My Schedule
    keyboard_arrow_down
    Aloïs Cochard

    Aloïs Cochard / Tony Morris - Introduction to Functional Programming using Haskell

    schedule 10:00 AM - 06:00 PM place Sigma Hall 2 people 13 Attending shopping_cart Reserve Your Seat

    We will be spending the day learning the fundamentals of Functional Programming (FP) using the Haskell programming language. The exercise material will be a condensed selection of the NICTA/course which is regularly held in Australia over three days.

    This one day session is targeted to experienced industry programmers who are looking to break into Functional Programming and develop the rudimentary skills and techniques that enable continued independent study. A refresher on Haskell syntax will be provided, however, it is highly recommended to practice with the syntax and development tools prior to obtain the best outcome for the day.

    You will be required to bring a suitable development machine (portable) for working through the exercises. You will also need to install Glasgow Haskell Compiler (http://www.haskell.org/ghc/) version 7.8 or higher on that machine prior to the day.

  • Added to My Schedule
    keyboard_arrow_down
    Francesco Cesarini

    Francesco Cesarini - Reactive Systems & MicroServices Architecture

    schedule 10:00 AM - 02:00 PM place Sigma Hall 3 people 15 Attending shopping_cart Reserve Your Seat

    You need to implement a fault-tolerant, scalable, soft, real-time system with requirements for high availability. It has to be event driven and react to external stimulus, load, and failure. It must always be responsive. You have heard many success stories that suggest Erlang is the right tool for the job. And indeed it is - but while Erlang is a powerful programming language, on its own, it's not enough to group these features together and build complex reactive systems. To get the job done correctly, quickly, and efficiently, you also need middleware, reusable libraries, tools, design principles, and a programming model that tells you how to architect and distribute your system.

    In this tutorial, we will look at the steps needed to design scalable and resilient systems. The lessons learnt apply to Erlang, but are in fact technology agnostic and could be applied to most stacks, including Scala/AKKA, Elixir/OTP and others.

  • Added to My Schedule
    keyboard_arrow_down
    Mark Allen

    Mark Allen - Masterless Multi-node Distributed Systems with riak_core

    schedule 10:00 AM - 06:00 PM place Sigma Hall 4 people 1 Attending shopping_cart Reserve Your Seat

    Learn step by step how to build your own masterless multi-node distributed systems using the riak_core library. This workshop covers each part of the riak_core environment so that you can build up robust, fault tolerant distributed systems that are resilient in the face of node failure.

    We will cover starting a new riak_core project, building up an API for the application, joining nodes to the cluster, handling node failure and handoff, and adding HTTP functionality/endpoints, step by step over the course of the day. By the end of the workshop, you will feel really comfortable building and managing your own custom riak_core application!

02:00
  • Added to My Schedule
    keyboard_arrow_down
    Kostis Sagonas

    Kostis Sagonas - A PropEr Tutorial on Property-Based Testing

    schedule 02:00 PM - 06:00 PM place Sigma Hall 3 people 3 Attending shopping_cart Reserve Your Seat

    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
08:30

    Registration - 30 mins

09:00
  • Added to My Schedule
    keyboard_arrow_down
    Francesco Cesarini

    Francesco Cesarini - An Introduction to Erlang - From behind the Trenches

    schedule 09:00 AM - 09:45 AM place Sigma Hall people 2 Attending

    Erlang is a programming language designed for the Internet Age, although it pre-dates the Web. It is a language designed for multi-core computers, although it pre-dates them too. It is a “beacon language”, to quote Haskell guru Simon Peyton-Jones, in that it more clearly than any other language demonstrates the benefits of concurrency-oriented programming. In this talk, I will introduce Erlang from behind the trenches. By introducing the major language constructs, describe their benefits and discuss the problems Erlang is ideal to solve. I will be doing so from a personal prospective, with anecdotes from my time as an intern at the Ericsson computer science lab at a time when the language was being heavily influenced and later when working on the OTP R1 release.

09:45

    Welcome Address - 15 mins

10:00

    Coffee/Tea Break - 15 mins

10:15
  • Added to My Schedule
    keyboard_arrow_down
    Peter Saxton

    Peter Saxton - All Chat Applications

    schedule 10:15 AM - 11:00 AM place Sigma Hall 1 people 3 Attending

    Elixir is a powerful tool. In just 15 minutes you can have an acceptable chat application. Here endeth the blog post, but wait you have more questions.

    How do you deploy your application? Is Docker necessary, or even useful? What about service discovery, secrets, load balancing and other cloud flavoured issues.

    Let's take that chat application and make it scalable, fault-tolerant and available. Using concrete examples I will provide solutions to all these questions and maybe even more.

  • Added to My Schedule
    keyboard_arrow_down
    Manoj Govindan

    Manoj Govindan - Learning Computer Architecture

    schedule 10:15 AM - 11:00 AM place Sigma Hall 2 people 2 Attending

    Computer Architecture begins with electronics. As computers are built layer upon layer starting with primitive gates baked into silicon, followed by chips and logic gates, hardware platform including ALU, RAM, cache etc., and so on, so is the study of computer architecture a study of each of these layers of abstraction.

    Students of computer architecture usually rely on simulators, often written in Java or similar imperative/object oriented languages, to aid their learning. Here are some examples of such a program:

    Simulating XOR gate

    As an Erlang/functional programming enthusiast studying computer architecture I decided to write my own equivalent tools in Erlang and TypeScript as I went about my learning. I am studying computer architecture and simultaneously writing the required simulators and other tooling in Erlang and TypeScript.

    Building such emulators and tools in Erlang and Typescript results in distinctly different architectures. I'll be demoing the simulator I built and talking about lessons learned doing this.

11:15
  • Added to My Schedule
    keyboard_arrow_down
    Luis Ferreira

    Luis Ferreira - Umbrella Apps - Winter is coming

    schedule 11:15 AM - 12:00 PM place Sigma Hall 1 people 3 Attending

    Yeah, that was a bad pun, but on this talk we’ll go over how to build an umbrella app in Elixir and Phoenix. As a bonus we’ll also cover a few of the differences between umbrella apps and microservices as well as how the Elixir community is moving towards a more thoughtful architecture for apps.

  • schedule 11:15 AM - 12:00 PM place Sigma Hall 2

    Unlock the full capabilities of Erlang's new software management tool, rebar3. This talk will explore some of the basic functionality in the tool including managing dependencies, compiling a project, running tests, packaging and publishing your code to hex.pm.

    But rebar3 can do more! Have you ever wanted to change how rebar handles a certain task? Now you can! We cover how to write plugins to modify and extend rebar's behaviors and how to create template files so rebar can help you start new code projects quickly and easily.

    Finally, we will spend a few moments talking about how to provide rebar2 compatibility from a rebar3 project. Don't keep using the same old thing - now there's something better!

12:15
  • Added to My Schedule
    keyboard_arrow_down
    Khaja Minhajuddin

    Khaja Minhajuddin - Building a collaborative painting canvas with Phoenix

    schedule 12:15 PM - 01:00 PM place Sigma Hall 1 people 2 Attending

    As the world is moving to parallel computing and real time messaging, we need robust technologies which support these new paradigms. Elixir being built on top of the Erlang VM is a robust and functional programming language which gives us both.

    In this talk we will look at the ease with which we can build a massive collaborative painting canvas which allows users to paint in collaboration with others in real time.

  • Added to My Schedule
    keyboard_arrow_down
    Pranav Rao

    Pranav Rao - Erlang and Akka Actors - A story of tradeoffs

    schedule 12:15 PM - 01:00 PM place Sigma Hall 2 people 1 Attending

    The Actor model has long been known to be great at modeling concurrent and parallel problems in a declarative, safe way. The challenge has always been the cost of this abstraction - implementing cheap message passing over a shared-nothing memory architecture while ensuring fairness is a tough ask. In this talk I shall go over how BEAM, with it's three decades of esoteric telecom engineering differs from Akka actors implemented over the JVM, arguably the most invested general purpose VM in existence today.

    Along the way, we shall discover how design decisions affect performance at each step of a program's execution - from a global/per-process heap affecting GC latencies and throughput, a type system's effects at efficiency, to preemptive scheduling improving long tail latencies.

01:00

    Lunch - 60 mins

02:00
  • Added to My Schedule
    keyboard_arrow_down
    Bryan Hunter

    Bryan Hunter - Elixir by the Bellyful

    schedule 02:00 PM - 02:45 PM place Sigma Hall people 5 Attending

    Elixir makes me happy, and I bet it will make you happy too. OK, but why is that? Elixir is a modern functional programming language with productive “dev joy” tooling, and it sits atop a decades-stable, crazy-scale, battle-tested foundation: the ErlangVM and OTP. In under three years after Elixir reached 1.0 it has already topped big, popular languages like C# on Stack Overflow’s "2017 Most Loved Language” list. After this session you will understand what makes Elixir special, the ecosystem will be illuminated, and you will have the "why, what, and how" knowledge to confidently begin your Elixir journey.

03:00
  • Added to My Schedule
    keyboard_arrow_down
    Emil Soman

    Emil Soman - Turn Hours into Seconds - Concurrent Event Processing

    schedule 03:00 PM - 03:45 PM place Sigma Hall 1 people 2 Attending

    For programmers who have been using locks for synchronizing threads to solve all concurrency problems, embracing message passing and creating concurrent data flows is an enlightening experience. This talk is a case study of a real world concurrency problem where the developer started with a slow non-thread-safe solution and refactored it step by step into a fast yet simple concurrent solution making use of Elixir's concurrent computation library called Flow.

  • Added to My Schedule
    keyboard_arrow_down
    Kostis Sagonas

    Kostis Sagonas - Targeted Property-Based Testing

    schedule 03:00 PM - 03:45 PM place Sigma Hall 2 people 1 Attending

    We introduce targeted property-based testing, an enhanced form of property-based testing that aims to make the input generation component of a property-based testing tool guided by a search strategy rather than being completely random. Thus, this testing technique combines the advantages of both search-based and property-based testing. We demonstrate the technique with the framework we have built, called Target, and show its effectiveness on three case studies. The first of them demonstrates how Target can employ simulated annealing to generate sensor network topologies that form configurations with high energy consumption. The second case study shows how the generation of routing trees for a wireless network equipped with directional antennas can be guided to fulfil different energy metrics. The third case study employs Target to test the noninterference property of information-low control abstract machine designs, and compares it with a sophisticated hand-written generator for programs of these abstract machines.

03:45

    Coffee/Tea Break - 15 mins

04:00
  • Added to My Schedule
    keyboard_arrow_down
    Cameron Price

    Cameron Price - Making it Fast: The Power of Benchmarking

    schedule 04:00 PM - 04:45 PM place Sigma Hall 1

    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
    keyboard_arrow_down
    Ravi Mohan

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

    schedule 04:00 PM - 04:45 PM place Sigma Hall 2 people 4 Attending

    Summary: An Experience Report on How I'm using Erlang and PureScript to create programmatic opponents aka 'bots' for complex boardgames I love to play but I can't find people to play with!

    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.

    ADP

    adpcards

    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 ...."

    WarOfRings1

    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.

    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, I use time and effort saving languages with good capabilities for abstraction(aka functional languages!),

    In this case I use Erlang (originally Haskell, I'm using this project to learn Erlang) for the backend and PureScript for the front end.

    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 list of lessons learned, victories *and defeats*, what worked *and 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

05:00
  • Added to My Schedule
    keyboard_arrow_down
    Gyanendra Aggarwal

    Gyanendra Aggarwal - A practical guide to GenStage with a real-life use case.

    schedule 05:00 PM - 05:45 PM place Sigma Hall 1 people 1 Attending

    Elixir GenStage is a very interesting abstraction (behavior) and can be used very effectively to solve many complex problems that fall under supply-demand/back-pressure scenarios. One can solve such problems by writing minimal amount of code by using GenStage. Come and learn in detail about the wonders of this abstraction with a real-life use case in Warehouse automation.

  • Added to My Schedule
    keyboard_arrow_down
    Chaitanya Chalasani

    Chaitanya Chalasani - High Performance Data Mart using Event Plots

    schedule 05:00 PM - 05:20 PM place Sigma Hall 2

    Reporting data for finite state machine transactions like calls require exhaustive data mining into 10s and 100s of parameters for 1000s of calls per hour. These postmortems require heavy processing and can demand millions of maps per reduction. The presentation is a case study and demonstration of near-realtime asynchronous event processing based plotting of events and states of FSMs. Thus creating semi-cooked event plots delivering lightening fast reports with extensive customizability.

05:25
  • Added to My Schedule
    keyboard_arrow_down

    Demos/Lightning Talks

    schedule 05:25 PM - 05:45 PM place Sigma Hall 2 people 1 Attending
06:00

    Keynote by Robert Virding - 45 mins

06:45

    Reception Dinner - 135 mins

Functional Conf

Sat, Nov 18
08:30

    Registration - 30 mins

09:00
  • Added to My Schedule
    keyboard_arrow_down
    Martin Thompson

    Martin Thompson - High Performance Managed Languages

    schedule 09:00 AM - 09:45 AM place Grand Ball Room people 1 Attending

    Common wisdom dictates that native languages are the only means of building high-performance applications. How do managed runtimes such as those available to Erlang, .NET, Java, and even JavaScript, yes even JavaScript compare? Many applications requiring high-performance are now developed for managed runtimes – such as financial trading, data stores and analytics, messaging, and even supercomputing.

    Over the last few decades we have seen significant advances in managed runtimes, particularly for JIT compilers and garbage collectors. In this talk we will explore how our managed runtimes can equal, and even better in some cases, the performance of native languages.

10:00

    Welcome Address - 15 mins

10:15

    Coffee/Tea Break - 15 mins

10:30
  • Added to My Schedule
    keyboard_arrow_down
    Ryan Lemmer

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

    schedule 10:30 AM - 11:15 AM place Grand Ball Room 1 people 2 Attending

    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: Rank-n types, GADTs, 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 "programming with types" to type-level programming, and ultimately dependently-typed programming in Haskell.

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

  • Added to My Schedule
    keyboard_arrow_down
    Aloïs Cochard

    Aloïs Cochard - The Tale of Troy

    schedule 10:30 AM - 11:15 AM place Grand Ball Room 2 people 2 Attending

    In recent years, the impact of functional programming on mainstream languages has grown significantly.

    After conquering server applications and distributed systems,
    the paradigm is now conquering the fields of web development and data analytics.

    So what remains? The land of system programming.

    When Mozilla did release the language Rust in 2012,
    it did immediately striked interest from functional programming enthusiasts due to it's strong emphasis on safety.

    Even though it currently lacks some advanced features like higher kinded types,
    it is built with functional programming principles as it's core.

    Like a Trojan horse (or the parasite mushroom after the language is named),
    Rust looks like the next C on the outside... while it might actually be closer to Haskell on the inside!

    Let's take a tour and discover an other side of system programming by learning together how to do functional programming in Rust.

  • Added to My Schedule
    keyboard_arrow_down
    Bryan Hunter

    Bryan Hunter - Poka yoke: Mistake-proofing via Functional Programming

    schedule 10:30 AM - 11:15 AM place ESquire Hall people 3 Attending

    "Poka yoke” (po-kah yo-kay) is a term from Japanese manufacturing that means "mistake proofing". It is a powerful concept (equally powerful in software) in which the design of a system shapes usage so that human error is prevented or corrected before it can cause real harm. In this session we will explore how and why FP maps so well onto the poka yoke concept. We will discuss the merits of mistake proofing over diligence, and rethink our approaches to craft and quality. You will leave with a new lens to evaluate languages, tools, and your own code. Examples in Elixir, Elm, F#, and Idris.

11:30
  • Added to My Schedule
    keyboard_arrow_down
    Tony Morris

    Tony Morris - Functional Programming in Aviation

    schedule 11:30 AM - 12:15 PM place Grand Ball Room 1 people 1 Attending

    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 Grand Ball Room 2 people 3 Attending

    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 ESquire Hall people 3 Attending

    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.

12:15

    Lunch - 45 mins

01:00
  • Added to My Schedule
    keyboard_arrow_down
    Manuel Chakravarty

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

    schedule 01:00 PM - 01:45 PM place Grand Ball Room 1 people 3 Attending

    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.

  • Added to My Schedule
    keyboard_arrow_down
    Roger Hui

    Roger Hui - Proofs, Derivations, Tests

    schedule 01:00 PM - 01:45 PM place Grand Ball Room 2 people 2 Attending

    John Hughes and Mary Sheeran in Why Functional Programming Matters [0] list “algebra as a litmus test” as one of the four salient features of functional programming, and Ken Iverson in Notation as a Tool of Thought [1] lists “amenability to formal proof” as one of the five important characteristics of notation. Using the language APL, we prove the correctness of some programs, derive simplifications, and illustrate design validation and program test techniques for functional programs.

    [0] Hughes, John, and Mary Sheeran, Why Functional Programming Matters, Code Mesh, London, 2015-11-02 to -04.

    [1] Iverson, Kenneth E., Notation as a Tool of Thought, Communications of the ACM, volume 23, number 8, 1980-08.

  • Added to My Schedule
    keyboard_arrow_down
    Eric Torreborre

    Eric Torreborre - Practical eff monad for micro-services

    schedule 01:00 PM - 01:45 PM place ESquire Hall people 1 Attending

    This talk presents how we use the Eff monad at Zalando to structure a REST microservice. Even when programming with functions, modules and components still matter, and I will present a new approach for dependency injection using the Reader monad (classic) and tree rewriting (what?). Then we will see how to specify more precisely several components (authentication, request to other services and database access) with the Eff monad and support additional concerns like logging or asynchronous execution.

    Once you get the basic idea, the possibilities are endless! Rate limiting is just another component and another set of effects involving time and state, testing becomes really clean and easy.

02:00
  • Added to My Schedule
    keyboard_arrow_down
    Jayaram Sankaranarayanan

    Jayaram Sankaranarayanan - A peek in to Elm Architecture

    schedule 02:00 PM - 02:45 PM place Grand Ball Room 1 people 2 Attending

    Elm Lang changes the way UI is built and brings in reliability , robust architecture and functional principles as an alternative to JavaScript and numerous JavaScript frameworks.

    In this session, attendees will be introduced to the basics of functional programming principles, using the Elm lang constructs, the Elm Architecture and how Elm enables easy and reliable refactoring.

  • Added to My Schedule
    keyboard_arrow_down
    Aaron W Hsu

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

    schedule 02:00 PM - 02:45 PM place Grand Ball Room 2 people 1 Attending

    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.

  • Added to My Schedule
    keyboard_arrow_down
    Mushtaq Ahmed

    Mushtaq Ahmed / Unmesh Joshi - Service Discovery using CRDTs

    schedule 02:00 PM - 02:45 PM place ESquire Hall people 2 Attending

    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.

02:45

    Coffee/Tea Break - 15 mins

03:00
  • Added to My Schedule
    keyboard_arrow_down
    Vimal Kumar

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

    schedule 03:00 PM - 03:45 PM place Grand Ball Room 1

    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 PM - 03:45 PM place Grand Ball Room 2 people 3 Attending

    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
    keyboard_arrow_down
    Riccardo Terrell

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

    schedule 03:00 PM - 03:45 PM place ESquire Hall people 3 Attending

    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#.

04:00
  • Added to My Schedule
    keyboard_arrow_down
    Abhiroop Sarkar

    Abhiroop Sarkar - Wormholes and teleporting with Transient.

    schedule 04:00 PM - 04:45 PM place Grand Ball Room 1

    The transient library in Haskell/Eta composes arbitrary pieces of software in concurrent, parallel and sequential settings using standard Haskell/Eta combinators like applicative, alternative, bind etc. It provides algebraic and monadically composable primitives for concurrency, parallelism, event handling, transactions and multithreading

    It liberates the programmers from dealing with state machines, objects frameworks, routes, configurations and callbacks. Transient expresses business functionalities as compact category theoretical expressions which compose. These compositions are verified during compilation, although the code might be executing in different machines.

    It presents a fresh new approach to programming concurrent and distributed systems.

     

  • Added to My Schedule
    keyboard_arrow_down
    Naresh Jain

    Naresh Jain - Array-Oriented Functional Programming in PHP

    schedule 04:00 PM - 04:45 PM place Grand Ball Room 2 people 1 Attending

    Array-oriented Programming (AoP) dates back to 1960s.The fundamental idea behind AoP is that operations apply at once to an entire set of values. This allows the programmer to think and operate on whole aggregates of data, without having to resort to explicit loops of individual scalar operations. At ConfEngine.com, a platform for organising and managing technical conferences/events, we've been heavily influenced by the APL style of AoP. In our context, this means each function focuses on applying one transformation to an immutable array (ordered-map) and then spitting out a new array, which can be piped to another function thus achieving functional composition. This has allowed us to build a very modular, decoupled design, which is extremely simple to reason about.

    If you think of typical web-apps, they are generally CRUD applications. Data comes in, you apply a set of transformation and you pass it to someone else via an API or you save/query a data store. And on the way out, you get data from somewhere (data-store, API, etc.), apply a set of transformations and render the transformed data as HTML or JSON. Now we can visualise most web-apps using standard Pipe-and-Filter Architecture. With this, applying some of the functional programming concepts becomes more intuitive.

    At ConfEngine.com, we use the standard LAMP stack. We've used PHP's philosophy of shared-nothing-architecture to address concurrency and scalability concerns. PHP itself has all the basic ingredients required for Functional Programming - first-class, higher-order functions, lambda, closures, partial functions, recursion and so on. We use array (ordered-map) to hold the data. PHP provides 79 array functions that allows you to do pretty much everything you need to in terms of transforming arrays including map, reduce, filter, merge and so on. One needs to be careful, but most of these are pure, higher-order functions.

    If you are interested to learn more about AoP, I'll give a walk through of our design. Also I'll take a couple of problems to explain how to think in terms of AoP and how its really helps with functional programming.

  • Added to My Schedule
    keyboard_arrow_down
    Naresha K

    Naresha K - Beyond Lambdas & Streams - Functional Fluency in Java

    schedule 04:00 PM - 04:45 PM place ESquire Hall

    Java 8 opened the doors for the developers to leverage the power of functional programming. Developers can apply techniques such as higher order functions, composition, and laziness with lambdas, and streams API introduced in Java 8. However, we would soon hit the limits if we extensively use the functional style of programming. In this demo, I will start with the examples that will show such limitations, and I will use a library called "Vavr" to overcome the limitations of Java 8 and bring in additional functional programming techniques that are not readily available in Java 8 language. My goal is to convey how to write fluent functional programs in Java without falling back on the conventional object-oriented techniques to fill the gaps.

05:00
  • Added to My Schedule
    keyboard_arrow_down
    Francesco Cesarini

    Francesco Cesarini - Concurrent Languages are Functional

    schedule 05:00 PM - 05:45 PM place Grand Ball Room people 4 Attending

    The functional paradigm has been influencing mainstream languages for decades, making developers more efficient whilst helping reduce software maintenance costs. As we are faced with a programming model that needs to scale on multi-core architectures, concurrency becomes critical. In these concurrency models, the functional programming paradigm will become even more evident. To quote Simon Peyton Jones, future concurrent languages will be functional; they might not be called functional, but the features will be.

    Using his 20 years of programming and teaching Erlang/OTP, Francesco will walk through the functional programming features that make implementations of the actor model viable in the Erlang ecosystem. These are features we might take for granted or do not think about, but have laid the foundation of multi-core and distributed programming, influencing programming languages, old and new.

06:00

    Closing Talk - 15 mins

Post-Conf Workshop

Sun, Nov 19
09:30

    Registration - 30 mins

10:00
  • Added to My Schedule
    keyboard_arrow_down
    Manuel Chakravarty

    Manuel Chakravarty - Functional Programming in Swift

    schedule 10:00 AM - 06:00 PM place Sigma Hall 1 people 2 Attending shopping_cart Reserve Your Seat

    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
    keyboard_arrow_down
    Ryan Lemmer

    Ryan Lemmer - Haskell Design Patterns

    schedule 10:00 AM - 06:00 PM place Sigma Hall 2 people 14 Attending shopping_cart Reserve Your Seat

    In this workshop we explore several areas of advances that make up Modern Haskell.

    (This is an experiential workshop, we will code together, and explore ideas together from first principles. You will need GHC 7.10 and up.)

    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.

    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
    keyboard_arrow_down
    Martin Thompson

    Martin Thompson - High-Performance Messaging with Aeron

    schedule 10:00 AM - 06:00 PM place Sigma Hall 3 people 17 Attending shopping_cart Reserve Your Seat

    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
    keyboard_arrow_down
    Riccardo Terrell

    Riccardo Terrell - Concurrent Functional Programming in .NET

    schedule 10:00 AM - 02:00 PM place Sigma Hall 4 shopping_cart Reserve Your Seat

    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.