filter_list help_outline
  • José Valim
    keyboard_arrow_down

    José Valim - Idioms for building fault-tolerant applications with Elixir

    José Valim
    José Valim
    Chief Adoption Officer
    Dashbit
    schedule 2 months ago
    Sold Out!
    45 Mins
    Keynote
    Intermediate

    This talk will introduce developers to Elixir and the underlying Erlang VM and show how they provide a new vocabulary which shapes how developers design and build concurrent, distributed and fault-tolerant applications. The talk will also focus on the design goals behind Elixir, use cases, and include some live demos.

  • Simon Peyton Jones
    keyboard_arrow_down

    Simon Peyton Jones - Hashing Modulo Alpha Equivalence

    45 Mins
    Keynote
    Intermediate

    In many applications, one wants to identify identical subtrees of a program syntax tree.  This identification should ideally be robust to alpha-renaming of the program, but no existing technique has been shown to achieve this with good efficiency (better than O(n^2) in expression size). We present a new, asymptotically efficient way to hash modulo alpha-equivalence. A key insight of our method is to use a weak (commutative) hash combiner at exactly one point in the construction, which admits an algorithm with O(n*(log n)^2) time complexity. We prove that the use of the commutative combiner nevertheless yields a strong hash with low collision probability.

  • Jon Carstens
    keyboard_arrow_down

    Jon Carstens - G'Day, Nerves!

    Jon Carstens
    Jon Carstens
    Core Team
    Nerves
    schedule 3 weeks ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    What is Nerves? What's the community like? How is it used?? These and more to be answered by this adventure into the world of functional embedded development using Elixir and the BEAM VM to create fault tolerant hardware systems...or blinking LED's...YMMV

  • Noam Zilberstein
    keyboard_arrow_down

    Noam Zilberstein - Eliminating Bugs with Dependently Typed Haskell

    Noam Zilberstein
    Noam Zilberstein
    Software Engineer
    Facebook
    schedule 1 month ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    Using dependent types in production Haskell code is a practical way to eliminate errors. While there are many examples of using dependent Haskell to prove invariants about code, few of these are applied to large scale production systems. Critics claim that dependent types are only useful in toy examples and that they are impractical for use in the real world. This talk analyzes real world examples where dependent types have enabled us to find and eliminate bugs in production Haskell code.

  • Robin Hilliard
    keyboard_arrow_down

    Robin Hilliard - Elixir for UAV Avionics

    Robin Hilliard
    Robin Hilliard
    Founder and CTO
    Rocketboots
    schedule 1 month ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    Fault tolerant, concurrent, distributed and functional with superior binary wrangling capabilities and network/device connectivity - the Erlang platform designed to run the world's telephony systems also turns out to be a perfect fit for autonomous aerial vehicle control software.

    In this presentation Robin will give a brief introduction to  the world of autonomous aircraft, autopilots, onboard companion computers, ground stations and communication links. He will demonstrate the use of his open source Elixir MAVLink library to communicate with an Ardupilot autopilot from Elixir code, which in turn will control an  accurate X-Plane simulation of a large UAV he has been working with since 2014.

  • Daniel Spiewak
    keyboard_arrow_down

    Daniel Spiewak - Journey to the Centre of the JVM

    30 Mins
    Talk
    Intermediate

    What do you do when your quest for power leads you to implementations which are not just platform- but processor- and even architecture-version-specific in nature? How do you even start tracking down a bug in a Scala-based implementation which is not only non-deterministic but only manifests on certain hardware? In this talk, we will dive into the wild and ill-understood world of CPU architecture, memory models, and JVM intrinsics (all through the lens of very high-level purely functional abstractions!) as we examine the story of the most convoluted and mind-bending bug hunt of my entire career.

  • Yann Hamdaoui
    keyboard_arrow_down

    Yann Hamdaoui - A tale of Nix and Nickel

    Yann Hamdaoui
    Yann Hamdaoui
    Software engineer
    Tweag I/O
    schedule 3 weeks ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    What do package management and functional programming have in common? More than it seems!

    In this talk, I will introduce the Nix package manager, which applies principles from functional programming to overcome fundamental challenges of package management. It crucially relies on a functional programming language, also called Nix, of which I will discuss the current state and shortcomings. I will finish presenting our new configuration language Nickel which attempts to solve some of them.

  • Bruce Tate
    keyboard_arrow_down

    Bruce Tate - Phoenix LiveView: Building Scalable Web Single Page Apps Doesn't Have to Hurt

    Bruce Tate
    Bruce Tate
    Founder
    Groxio
    schedule 3 weeks ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    Meet Phoenix LiveView, the Elixir-based programming environment for Phoenix. The author of Programming Phoenix LiveView and LiveView trainer will walk you through how the programming model works. Along the way, you'll see what web development is supposed to feel like. The best thing? You'll be able to build the interactive single-page apps your customers want without compromising on code organization or writing custom JavaScript. 

  • David Vollbracht
    keyboard_arrow_down

    David Vollbracht / Trevis Elser - In The Belly Of The Whale: Tales From Haskell In The Enterprise

    30 Mins
    Talk
    Intermediate

    What is it like to bring Haskell to a large enterprise with an established
    culture? There are success stories for specialized teams, but what about the mainstream? We've been working in the trenches alongside enterprise developers doing Haskell for nearly 3 years and have lots to report. Ranging from the Haskell language and the ecosystem around it to how it has impacted the systems and people working with it, we will examine the journey from an introduction that took us into stormy seas and the vision of clear skies ahead.

  • John Hughes
    keyboard_arrow_down

    John Hughes - Testing smart contracts with QuickCheck

    John Hughes
    John Hughes
    Creator
    QuickCheck
    schedule 1 month ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    I will talk about some recent work on a random testing framework for smart contracts on the Cardano blockchain--which supports the world's largest "proof of stake" cryptocurrency. In contrast to the Ethereum blockchain, Cardano contracts are written in Haskell, but of course, they still need to be tested. I'll talk about the testing framework we've built, and its most novel aspect: not only must we test that nothing bad ever happens, but also that something good is always possible.

     

  • K C Sivaramakrishnan
    keyboard_arrow_down

    K C Sivaramakrishnan - Effective Programming in OCaml

    30 Mins
    Talk
    Intermediate

    Effect handlers have been gathering momentum as a mechanism for modular programming with user-defined effects. Effect handlers allow for non-local control flow mechanisms such as generators, async/await, lightweight threads and coroutines to be composably expressed. The Multicore OCaml project retrofits effect handlers to the OCaml programming language to serve as a modular basis of concurrent programming. In this talk, I will introduce effect handlers in OCaml, walk through several examples that illustrate their utility, describe the retrofitting challenges and how we overcome them without breaking the existing OCaml code. Our implementation imposes negligible overhead on code that does not use effect handles and is efficient for code that does. Effect handlers are slated to land in OCaml after the addition of parallelism support.

  • Lars Hupel
    keyboard_arrow_down

    Lars Hupel - A History of Enterprise Monads

    Lars Hupel
    Lars Hupel
    Senior Consultant
    INNOQ
    schedule 1 month ago
    Sold Out!
    30 Mins
    Talk
    Intermediate
     

    The early 2010’s were exciting times for Scala. The language & ecosystem started to professionalize, both from a technical (binary compatibility) and a community point of view (many conferences were started). Not too long after Lightbend – then Typesafe – was founded, I registered the typelevel.org domain on a whim and put together a rudimentary website advertising a few FP-minded Scala libraries. Fast forward to today: Typelevel is known for a wealth of functional libraries, beginner-friendly educational resources, a series of conferences and a distinct ecosystem – including a custom compiler – within the Scala community. In this talk, I’d like to examine what got us there and into the mainstream.

  • Jakub Kozłowski
    keyboard_arrow_down

    Jakub Kozłowski - Connecting the dots - building and structuring a functional application in Scala

    30 Mins
    Talk
    Intermediate

    Functional programming relies on building programs from orthogonal, composable blocks. That's likely one of the reasons why full-blown application frameworks haven't gained much traction in the functional ecosystem.

    However, we still need to structure our code and wire up our applications in a way that lets us keep them modular, testable and simply pleasant to work with - in this talk, we will learn how to do just that!

    In this talk, we will walk through the architecture design and testing setup for a functional app on the Typelevel stack that integrates with several third-party services to process data in a streaming fashion, and expose its results to downstream clients.

  • George Wilson
    keyboard_arrow_down

    George Wilson - Cultivating an Engineering Dialect

    30 Mins
    Talk
    Intermediate

    Haskell has seen success in commercial environments, with teams of professional engineers choosing it for its claims of reliability, a rapid development pace, and easier maintenance over the long term. On top of that, a large community of hobbyist tinkerers and academic researchers are always releasing new and exciting abstractions, libraries, and language extensions, each offering improved ways to structure, build, and test our programs.

    Engineering teams have diverse knowledge and skill levels, and new team members need to come up to speed to work effectively. This poses us a challenge: which abstractions, libraries, and language extensions should we choose from the ever-growing pool? How should we determine what level of Haskell to adopt? Should we always embrace the cutting-edge to squeeze out every advantage, leaving new hires in the dust? Should we reject novelty and focus only on the “simple” or “boring” ways of doing things, even if doing so gives up some potential effectiveness?

    This talk will bring clarity to these questions. Rather than prescribe a uniform solution, we offer you the tools of thought to make informed, intentional decisions, and cultivate an engineering dialect that works for you.

  • Dana Ma
    keyboard_arrow_down

    Dana Ma - Abstract Fun-sense: a functional perspective on life

    Dana Ma
    Dana Ma
    Staff Software Engineer
    Zendesk
    schedule 1 month ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    Everything can be a function if you look at it the right way; we can characterise familiar concepts like sets, lists and even plain values as functions.

    Thinking about such basic objects as functions can seem unnecessarily abstract, but it isn’t just an exercise in increasingly intimidating notation! It turns out to be an elegant perspective that allows us to glimpse a more powerful abstraction.

    In this talk, we’ll see how playing with this notion leads to the Yoneda Lemma, a key result in category theory. We’ll build up some intuition and motivation for the Yoneda Lemma, and return to the notion of viewing objects as functions to appreciate some of its implications.

  • Rúnar Bjarnason
    keyboard_arrow_down

    Rúnar Bjarnason - Unison: a friendly programming language from the future

    Rúnar Bjarnason
    Rúnar Bjarnason
    Co-Founder
    Unison Computing
    schedule 1 month ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    Unison is a new open source functional programming language based on a simple idea with big implications: every type and definition in the language has a unique cryptographic signature, determined by its content. Instead of a bag of mutable text files, the Unison codebase is a distributed immutable data structure and the signature serves as a global address into this structure. This is the basis for some serious improvements to the developer experience. Unison has no builds, no dependency conflicts in the traditional sense, and it allows for easy dynamic deployment of code in a distributed setting.

  • Don Syme
    keyboard_arrow_down

    Don Syme - What’s new in F# 5.0 and beyond

    Don Syme
    Don Syme
    Principal Researcher
    Microsoft
    schedule 2 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    The F# language delivers practical, enjoyable, and productive programming for the era of the cloud. At the core of F# is succinct, performant functional-first programming, compiling to both .NET and Javascript, with cross-platform, open-source toolchains for those at home in either ecosystem.

    In this talk I’ll describe how in F# 5.0 and beyond we are adding more magic right across the F# stack – keeping programming simple and correct yet delivering the features you need for maximum productivity:

    • Added expressivity and performance for DSLs using F# computation expressions
    • High-performance state machines and resumable code for functional DSLs for collections, tasks, asynchronous sequences, and more
    • Improved package management integration in F# scripting
    • Interactive notebooks and a wide range of other tooling improvements
    • F# analyzers, e.g. for additional shape checking in AI tensor programming
    • Turnkey programming stacks for the client, server, and full-stack programming

    Join me for this walk through the latest in 2021 for F#

  • Dr. Niki Vazou
    keyboard_arrow_down

    Dr. Niki Vazou - Resource Analysis with Refinement Types

    30 Mins
    Talk
    Intermediate

    Liquid Haskell is an extension of Haskell’s Type system that allows annotating types with refinement predicates. It’s great for ensuring the correctness of your code, but it can also be used to improve the performance of your code.

    If you track your resources then Liquid Haskell can be used to statically bound the resources needed at runtime, thus statically deciding how performant your code is. You are liquidating your assets.

    To track resource we define a `Tick monad that ticks each time a resource (ranging recursive calls to thunks) is used. Then we use refinement types to statically approximate the number of ticks that can occur at runtime. This reasoning aids runtime code optimization, since it can be used to compare resource usage of two different programs.

    In this talk, I will present this technique through small examples (sorting algorithms and mapping) and discuss the advantage and current limitations on real-world code adaptation.

  • No more submissions exist.
Looking for your submitted proposals. Click here.
help