• Liked Martin Thompson
    keyboard_arrow_down

    Martin Thompson - Functional Performance

    45 Mins
    Keynote
    Intermediate

    We have all heard stories of how functional programming will solve the multi-core problem. Yet we have also heard stories of how functional programming can have performance issues. If not where have you been hiding that last 10 years? How do we separate the facts from the alternative facts? In this talk we explore the inner workings of our current platforms to resolve the question of whether functional programming can provide good performance and satisfy our multi-core needs.

    This talk will cover the most relevant laws governing software performance and put them into context with evidence taken from building implementations to serve the most demanding financial domains.

  • Liked Vimal Kumar
    keyboard_arrow_down

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

    Vimal Kumar
    Vimal Kumar
    CEO
    JUSPAY
    schedule 3 months ago
    Sold Out!
    45 Mins
    Case Study
    Intermediate

    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.

  • Liked Manuel Chakravarty
    keyboard_arrow_down

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

    45 Mins
    Demonstration
    Intermediate

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

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

  • Liked Robert Virding
    keyboard_arrow_down

    Robert Virding - Pilgrim's Progress to the Promised Land

    Robert Virding
    Robert Virding
    Language Expert
    Erlang Solutions
    schedule 1 month ago
    Sold Out!
    45 Mins
    Keynote
    Intermediate

    When migrating to Elixir/OTP from other languages and systems a number of issues will always crop up. The trick is to make sure that these issues don't become problems. This talk will look at some of the more common ones and what to do about them to make sure they don't become problems.

  • Liked Kostis Sagonas
    keyboard_arrow_down

    Kostis Sagonas - Targeted Property-Based Testing

    45 Mins
    Original Research
    Beginner

    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.

  • Liked Mark Allen
    keyboard_arrow_down

    Mark Allen - Rebar3

    Mark Allen
    Mark Allen
    Principal Developer
    Alert Logic
    schedule 2 months ago
    Sold Out!
    45 Mins
    Talk
    Beginner

    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!

  • Liked Francesco Cesarini
    keyboard_arrow_down

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

    45 Mins
    Keynote
    Intermediate

    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.

  • Liked Francesco Cesarini
    keyboard_arrow_down

    Francesco Cesarini - Concurrent Languages are Functional

    45 Mins
    Keynote
    Beginner

    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.

  • Liked Robert Virding
    keyboard_arrow_down

    Robert Virding - Deep Dive into Erlang Ecosystem

    Robert Virding
    Robert Virding
    Language Expert
    Erlang Solutions
    schedule 1 month ago
    Sold Out!
    480 Mins
    Workshop
    Beginner

    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.

  • Liked Riccardo Terrell
    keyboard_arrow_down

    Riccardo Terrell - Concurrent Functional Programming in .NET

    Riccardo Terrell
    Riccardo Terrell
    Software Architect
    Excella
    schedule 3 months ago
    Sold Out!
    480 Mins
    Workshop
    Intermediate

    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.

  • Liked Francesco Cesarini
    keyboard_arrow_down

    Francesco Cesarini - Reactive Systems & MicroServices Architecture

    Francesco Cesarini
    Francesco Cesarini
    Founder & Technical Director
    Erlang Solutions
    schedule 3 months ago
    Sold Out!
    240 Mins
    Workshop
    Intermediate

    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.

  • Liked Kostis Sagonas
    keyboard_arrow_down

    Kostis Sagonas - A PropEr Tutorial on Property-Based Testing

    Kostis Sagonas
    Kostis Sagonas
    University Professor
    Uppsala University
    schedule 1 month ago
    Sold Out!
    240 Mins
    Workshop
    Beginner

    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.

  • Liked Mark Allen
    keyboard_arrow_down

    Mark Allen - Masterless Multi-node Distributed Systems with riak_core

    Mark Allen
    Mark Allen
    Principal Developer
    Alert Logic
    schedule 2 months ago
    Sold Out!
    480 Mins
    Workshop
    Beginner

    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!

  • 45 Mins
    Demonstration
    Beginner

    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.

  • Liked Eric Torreborre
    keyboard_arrow_down

    Eric Torreborre - Practical eff monad for micro-services

    Eric Torreborre
    Eric Torreborre
    Senior Software Engineer
    Zalando
    schedule 10 months ago
    Sold Out!
    45 Mins
    Talk
    Advanced

    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.

  • Liked Pushkar Kulkarni
    keyboard_arrow_down

    Pushkar Kulkarni - Power extreme: Algebraic data types and pattern matching

    Pushkar Kulkarni
    Pushkar Kulkarni
    Software Developer
    IBM
    schedule 4 months ago
    Sold Out!
    45 Mins
    Talk
    Beginner

    Computer programs may be simplistically viewed as an interplay between objects of given types based on operations defined on the types, and conforming to the laws on those types. The types may be as fundamental as an integer or as complex as an abstract syntax tree in a compiler. Compound types are defined using other types, or recursively too, using an algebra. Hence the name algebraic data types

    The two major operations when working with algebraic data type are construction and deconstruction. Construction is achieved simply through constructors! Deconstruction is achieved by what is generally referred to as pattern matching - a powerful technique that may be applied for all kinds of processing of an object of an algebraic type. A talk on algebraic types is incomplete without dealing with the concept pattern matching.

    This session proposes to take the audience through the implementation of a simple LISP interpreter in Swift to help appreciate the theory around Algebraic Data Types (ADTs) and pattern matching - both of which are language features in Swift. In Swift parlance, ADTs are referred to as tuples (product types) and enums (sum types).

    The session is targeted to enable the audience completely appreciate the Wikipedia definition of an ADT: "A general algebraic data type is  possibly a recursive sum type of product types". The objective is to show that thinking in terms of algebraic types is a crucial part of the larger paradigm of functional thinking.

  • Liked Aaron W Hsu
    keyboard_arrow_down

    Aaron W Hsu - Functional Array Funhouse Intensive

    Aaron W Hsu
    Aaron W Hsu
    Computer Scientist
    Indiana University
    schedule 5 months ago
    Sold Out!
    480 Mins
    Workshop
    Intermediate

    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.

  • Liked Aloïs Cochard
    keyboard_arrow_down

    Aloïs Cochard - The Tale of Troy

    45 Mins
    Demonstration
    Beginner

    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.

  • Liked Aaron W Hsu
    keyboard_arrow_down

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

    Aaron W Hsu
    Aaron W Hsu
    Computer Scientist
    Indiana University
    schedule 3 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    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.

  • Liked Peter Saxton
    keyboard_arrow_down

    Peter Saxton - All Chat Applications

    Peter Saxton
    Peter Saxton
    Senior Engineer
    Curl
    schedule 4 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    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.