Robert Virding - Pilgrim's Progress to the Promised Land

schedule 1 year 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.

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

schedule 1 year ago

Sold Out!

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.

Francesco Cesarini - Concurrent Languages are Functional

schedule 1 year ago

Sold Out!

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.

Martin Thompson - Functional Performance

schedule 1 year ago

Sold Out!

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.

Bryan Hunter - Elixir by the Bellyful

schedule 2 years ago

Sold Out!

45 Mins

Keynote

Beginner

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.

schedule 1 year 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.

Kostis Sagonas - Targeted Property-Based Testing

schedule 1 year ago

Sold Out!

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.

Mark Allen - Rebar3

schedule 1 year 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!

Riccardo Terrell - Concurrent Functional Programming in .NET

schedule 1 year 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.

Robert Virding - Deep Dive into Erlang Ecosystem

schedule 1 year 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.

Kostis Sagonas - A PropEr Tutorial on Property-Based Testing

schedule 1 year 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.

Mark Allen - Masterless Multi-node Distributed Systems with riak_core

schedule 1 year 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!

Francesco Cesarini - Reactive Systems & MicroServices Architecture

schedule 1 year 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.

schedule 2 years ago

Sold Out!

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.

schedule 1 year ago

Sold Out!

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.

schedule 1 year ago

Sold Out!

45 Mins

Case Study

Intermediate

We have spent the better part of a year introducing Haskell, typed languages, and functional programming, at Vacation Labs. After writing 250,000+ lines of code in dynamically typed languages (Rails & Javascript), we wanted more from our tech-stack:

The ability to fearlessly refactor as our market and our code evolved.

The ability to write only meaningful tests, and to increase coverage without increasing dev effort.

To share data structures across the backend & frontend.

And finally, the ability to continue developing features at speed - something that we take for granted in Rails.

In this talk, we will share our experience of using Haskell, with the focus on what the ecosystem enables us to do today, pragmatically. By the end of this talk, you will know the pros and cons of using Haskell in a real-world setting, and how to contribute in making the ecosystem better. (An aside, we aren’t using Haskell on the frontend, but Typescript, which also gives us quite a few of the abilities mentioned above).

Eric Torreborre - Practical eff monad for micro-services

schedule 2 years 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.

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

schedule 1 year 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.

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

schedule 1 year ago

Sold Out!

45 Mins

Talk

Intermediate

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.

schedule 1 year 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.