Skip to main content

Logo for BOB BOB 2020

28th February 2020

Berlin, Germany

Part of the BOB series
Lohmann & Birkner »

Talks A

Sessions in this room

  1. in Talks A

    Practical ReasonML (Marco Emrich)

    Static type systems have arrived in the frontend! Typescript and Flow made them popular. ReasonML – the language by React Framework inventor Jordan Walke – goes one step further and brings a functional programming language from the ML family into the browser. ReasonML combines the semantics of OCaml with the common syntax of JavaScript.

    How well does this work in practice? How easily can ReasonML be integrated into the existing JS ecosystem? How well do SinglePage apps work with ReasonReact? Where does ReasonML stand in comparison to TypeScript on one side or Elm on the other? We tried it in real projects, and the talk will be about our experience, which projects are worth using Reason and when you should rather do without it.

  2. in Talks A

    The Object-Oriented/Functional-Programming symmetry (Gabriel Scherer)

    Much gets written on the internet about comparisons between Object-Oriented (OO) and Functional-Programming (FP) approaches software: which one is going to solve all your programming problems? If we concentrate on precise, objective comparisons and relations between the two sides, the programming-language folklore mentions a symmetry (often called a "duality") between object-oriented and functional-programming styles. More precisely, a symmetry between program organizations based on class decompositions, and those based on sum types (also called variant types or algebraic datatypes). In this talk we propose to revisit this symmetry, discussing both practical and theoretical aspects.

  3. in Talks A

    A Nokia 3310 Ringtone Player in Elm (Ju Liu)

    In this talk we build a web application in Elm that reads some good old school Nokia 3310 ringtones and plays them in a browser. We will explore how to write a parser to interpret the Ring Tone Text Transfer Language (RTTTL) format and how to use modern Web Audio APIs to recreate those iconic sounds. We will conclude the talk by playing a selection of tunes, applying some effects and having a good time.

  4. in Talks A

    Criminally fast Rust and Breaking Safety for Fun and Profit (Darach Ennis & Heinz Gies)

    In this talk, we confess our rusty sins: memory manipulation, unsafe code, lying to the borrow tracker, lifetime crimes, and many more. Criminally fast rust is possible, and we share what worked for us, what didn’t, and why we broke the safe.

    Over the past year we’ve been building Tremor - an event processing system used at Wayfair to process billions of messages per minute 24x7x365. This is our first project as an organization and as individuals with the Rust programming language.

    We’ve learned a lot: to hate rust, to love it, to hate and love it again; there are things we did badly, some we did terribly as we bent to the borrow trackers demands, before bending the borrow tracker to our needs.

  5. in Talks A

    What is Functional Reactive Programming? (Tikhon Jelvis)

    How can we work with time in functional programming? Traditionally, reactive systems—UIs, web servers, robotic controllers, simulations—are seen as inherently imperative, not suitable for functional programming. This does not have to be the case! Functional Reactive Programming (FRP), lets us have our cake and eat it too: we can use the composable, declarative style we love as functional programmers to write this kind of code. But what is FRP? It's surprisingly hard to get a clear answer without diving deeply into research literature. I will give you an introduction with practical Haskell examples that will get you over the hump to understanding and using FRP.

  6. in Talks A

    JS, Rust, Python and the Holy Graal (Lars Hupel)

    In the old times, way back, Java used to be the only JVM language. Later on, a few other players entered the field, such as Jython and JRuby. But those were just for scripting, right? It didn’t take long for compiled languages to catch up. With Scala and Kotlin, we have definitely entered the age of polyglot programming on the JVM. The Truffle project – part of GraalVM – is a promising approach to make it easy, efficient, and seamless to run alternative languages on the same VM as Java. This talk will look at the new age of polyglot programming and all the cool things we can do with it.

  7. in Talks A

    The Essence of Programming (Ludvig Sundström)

    Referential transparency is a property that lets us better understand computer programs, because it allows us to safely replace expressions with their values without changing the programs behavior in other places. To achieve referential transparency, we have to program using pure functions and function composition as primary tools.

    Seen abstractly, the process of composing and decomposing of pure functions closely relate to the essential principle of problem: “To solve a large problem, split it up into subproblems and solve these recursively, then combine the solutions.” What implications does this correlation have on functional programs?

    In this talk, I argue why function composition is the essence of programming, and how it manifests itself through some abstractions we know from the functional world.