filter_list help_outline
  • Saša Jurić
    keyboard_arrow_down

    Saša Jurić - Simplifying systems with Elixir

    Saša Jurić
    Saša Jurić
    Software Developer
    independent
    schedule 5 months ago
    Sold Out!
    45 Mins
    Invited Talk
    Intermediate

    Elixir is often described as a language which offers great support for massive concurrency. First-hand reports cite the ease of handling millions of connected users, sub-millisecond response times, and superb fault-tolerance. These are all great benefits, but we’re left wondering whether Elixir is useful only for large scale systems, or can it bring some benefits in the simpler cases too?

    This talk aims to demonstrate that Elixir is also a great choice for building smaller systems. Through a very simple but still a real-life example, I’ll explain how using Elixir can help simplify the system architecture, and lead to a more homogeneous solution. The talk targets backend developers who are new to Elixir. After the talk, the audience will have a clearer idea about what makes Elixir attractive, and why should they consider using it to build their next backend system.

  • Francesco Cesarini
    keyboard_arrow_down

    Francesco Cesarini - Immutability for Concurrency

    45 Mins
    Invited Talk
    Intermediate

    Functional programming has been influencing mainstream languages for decades, making developers more efficient whilst helping them reduce maintenance costs. As we are faced with a programming model that needs to scale on multi-core architectures and distributed environments, concurrency becomes critical. In these concurrency models, immutability, a key feature of 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. In this talk, we explain why!

  • Mark Hibberd
    keyboard_arrow_down

    Mark Hibberd - Systems That Don't Forget

    Mark Hibberd
    Mark Hibberd
    CTO
    Kinesis
    schedule 5 months ago
    Sold Out!
    45 Mins
    Invited Talk
    Intermediate

    Software systems form an intrinsic feedback loop, the more we use and rely on a system, the more we demand of that system. This loop drives a cost and complexity that if left unchecked eventually inhibits growth and improvements to the software or in the worst case brings it crashing down.

    The crux of this complexity in many (most?) systems is the management of state and data over time, and importantly how different systems co-ordinate around that state. If we look to modern, and even not so modern, software we can see a recurring pattern to dealing with this through the use of immutable, persistent data. We see this pattern from databases and distributed systems through to user interface frameworks. Building complex systems that work correctly, reliably and efficiently often comes down to building systems that don't forget.

    In this talk we will look at the design, benefits and challenges of building a system around the ideas of immutable and persistent data using a specific example of a system that I work on to support urban planning & climate policy modelling.

  • Afsal Thaj
    keyboard_arrow_down

    Afsal Thaj - Unveiling much simplified Functional Programming in Scala for Data Engineering

    Afsal Thaj
    Afsal Thaj
    Principal Consultant
    Simple Machines
    schedule 5 months ago
    Sold Out!
    30 Mins
    Invited Talk
    Intermediate

    I will talk about a much simplified version of functional programming in Scala, in building an abstraction for Feature Generation in Data Engineering space.
    The program made using this abstraction will get interpreted to the popular data source languages of our choice - such as Spark or Flink. However, before it gets interpreted to any of these engines, we will explain how these programs could be optimised by introspecting its nodes, and help run these interpretations faster. The core idea is similar to that of Free Applicative, however, implementing it in Scala hasn't been straight forward. Here, we provide a similar capability but without mentioning much about FreeAp, and without the usual Scala boilerplates of implicits, macros and a proliferated usage of type classes.

    The purpose of the talk is not just to demonstrate a set of code, but to showcase the fact that sticking on to fundamentals of Functional Programming, and finding the right abstraction enables writing solutions quickly and relatively easily.

    It proves we don't need to learn a bulk of libraries to apply these concepts in real world applications. The learning curve and a massive set of libraries was often termed as the functional programming in Scala industry, resulting in lesser adoption and developers moving away from it. With this talk my intention is to motivate developers to come back and start writing FP even if they are in the world of JVM.

  • Sophie  DeBenedetto
    keyboard_arrow_down

    Sophie DeBenedetto - It's Alive!!! Instrumenting Phoenix 1.5 with Telemetry and Live Dashboard

    Sophie  DeBenedetto
    Sophie DeBenedetto
    Engineer
    GitHub
    schedule 5 months ago
    Sold Out!
    30 Mins
    Invited Talk
    Intermediate

    Phoenix 1.5 is here and it comes powered up with out-of-the-box instrumentation and visualization thanks to Telemetry and Live Dashboard.

    Phoenix now integrates Erlang's Telemetry library to aggregate and report on standard Phoenix, Ecto and Elixir VM Telemetry events as well as any custom events you'd care to emit from your own application. The Live Dashboard library allows us to visualize the metrics, performance and behavior of our app, as described by these events in real-time. These two offerings together empower every Elixir developer to hit observability goals by writing and shipping fully instrumented code with ease.

    In this talk, we'll take a tour through Live Dashboard's usage and features and we'll dive under the hood to understand how it leverages Erlang and Elixir's Telemetry libraries to capture and visualize events as metrics. There will be an obligatory picture of Frankenstein.

  • Stephanie  Weirich
    keyboard_arrow_down

    Stephanie Weirich - Strongly Typed System F in GHC

    45 Mins
    Invited Talk
    Intermediate

    There are many examples that demonstrate how to create a strongly typed abstract syntax in Haskell for a language with a simple type system. But there are many fewer examples that allow the embedded language to be polymorphic. I will work through what it takes to do so, touching on variable binding representations, and exploring the limits of dependently-typed programming in GHC.

  • Martin Odersky
    keyboard_arrow_down

    Martin Odersky - Implicits Revisited

    45 Mins
    Invited Talk
    Intermediate

    I talk about the history of how Scala's implicits evolved, about some of the mistakes we could have avoided in hindsight, and about aspects that I believe we got right. I then present the new system of givens in Scala 3, which replaces implicits. This system fixes most of the existing issues, increases safety and predictability and offers some exciting new possibilities to structure and modularize code.

  • Michael Pilquist
    keyboard_arrow_down

    Michael Pilquist - Scodec for Scala 3

    Michael Pilquist
    Michael Pilquist
    Distinguished Engineer
    Comcast
    schedule 5 months ago
    Sold Out!
    45 Mins
    Invited Talk
    Intermediate

    Scala 3 introduces new features which help manage complexity. In this talk, we’ll look at porting Scodec from Scala 2 to Scala 3, using new language features to simplify the library.

    You’ll see the ease of migrating projects to Scala 3 and perhaps be inspired to port some of your own.

  • Edward Kmett
    keyboard_arrow_down

    Edward Kmett - Cadenza: Building Fast Functional Languages Fast

    45 Mins
    Invited Talk
    Intermediate

    In this talk Ed will give live coding introduction to normalization by evaluation. He will then show how Graal and Truffle, on the JVM, can be (ab)used to JIT functional languages. He discussesd why this seems like a promising direction for evaluating dependently typed languages in particular.

  • Ulf Wiger
    keyboard_arrow_down

    Ulf Wiger - The Secret Sauce of Erlang: Opinionated Language and Focused Community

    Ulf Wiger
    Ulf Wiger
    Founder/CEO
    Wiger Pilotti Unlimited AB
    schedule 5 months ago
    Sold Out!
    45 Mins
    Invited Talk
    Intermediate

    As one who joined the Erlang community before it really even was one, I've had reason to consider and debate what makes Erlang special. Because it _is_ special. In this talk, I will summarize some of my own thoughts on the matter, exemplified by some war stories. My thesis is that while the impetus for creating the language is important, the evolution of the community and the niches where Erlang got some traction also play a vital role. Learning what has been successful in Erlang, what hasn't, and why, could give important clues not just to future adopters, but perhaps also to other communities (Elixir?) still developing a personality.

  • Josh Price
    keyboard_arrow_down

    Josh Price / Paul Fioravanti - Intro to Elixir

    480 Mins
    Workshop
    Beginner

    This workshop is an online workshop that will take place over two days:

    • Monday 20 July: 1pm - 5pm
    • Tuesday 21 July: 1pm - 5pm

    Elixir is an extremely accessible functional programming language that is rapidly gaining popularity for good reason. With it's well curated, batteries-included tool chain, excellent documentation and its sheer simplicity, not to mention its incredible 30+ year Erlang heritage.

    The goal of this workshop is to get you a basic familiarity with Elixir and the tools you'll need to be effective working in the language. It will be aimed at programmers who don't know Elixir, and don't necessarily know any functional programming.

    The workshop is organised around a set of exercises that should take you through the basics of the language. Once you've got to grips with the language and tools you'll be ready to build a real time game server. In this workshop you'll learn everything you need to start building amazing, production ready Elixir applications.

  • Ben Hutchison
    keyboard_arrow_down

    Ben Hutchison - Modes of Composition in Functional Scala Programming

    Ben Hutchison
    Ben Hutchison
    Software Architect
    Seek
    schedule 5 months ago
    Sold Out!
    480 Mins
    Workshop
    Intermediate

    This workshop is an online workshop that will take place over two days:

    • Monday 20 July: 10am - 12:10pm
    • Tuesday 21 July: 10am - 12:10pm

    This workshop teaches strongly typed, effectful functional program design in Scala. We will explore how techniques for composing and decomposing functional programs work in an applied scenario around ecommerce order processing.

    Composition is a central value in functional programming; the idea is that we build larger, more complex software by composing smaller, simpler pieces. Making it easy to combine pieces together is a key attribute of good programming methods.

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