Skip to main content

Logo for BOB BOB 2020

28th February 2020

Berlin, Germany

Part of the BOB series

Schedule for

  1. in Main Room

    Opening Performance (Alexandra Cárdenas)

    Composer, programmer and improviser of music, Alexandra Cárdenas has followed a path from Western classical composition to improvisation and live electronics. Using open source software like Super Collider and Tidal, her work is focused on the exploration of the musicality of code and the algorithmic behaviour of music. An important part of this exploration consists of the practice of live coding, including performances at the forefront of the Algorave scene. Currently she lives in Berlin, Germany and is doing her masters in Sound Studies at the Berlin University of the Arts.

    Samples of her work are on her YouTube channel.

  2. in Main Room

    Keynote (Heather Miller)

    Heather Miller is a professor at Carnegie Mellon University, in the School of Computer Science, primarily affiliated with the Institute for Software Research. Formerly, she was the co-founder and Executive Director of the Scala Center at EPFL. She was also an Assistant Clinical Professor in the College of Computer and Information Science at Northeastern University.

    Some of her projects include programming models and type systems to facilitate the design of new, functional distributed systems, such as distributable closures, flexible, extensible, and performant serialization, asynchronous and concurrent programming via futures and promises, and deterministic concurrent dataflow.

    She works on and around the Scala programming language.

  3. in Tutorials A

    Introduction to Idris (Stefan Wehr)

    Idris is a strongly typed functional programming language with dependent types. The language is inspired by Haskell with similar syntax and language features. Idris supports algebraic data types, pattern matching, control over side-effects, higher-order functions and type classes.

    But Idris also supports dependent types, meaning that terms can be used on the type-level. Thus, dependent types offer to possibility to use the rich term language to compute types, allowing programers to express many invariants on the type-level that would otherwise being checked at runtime (or not at all). A simple example of such an invariant is that an index accessing a specific element of an array must be within the bounds of the array. More complex properties are expressible as well, for example that a search tree fulfills the search tree property or that an SQL query is compatible with a certain database schema.

    The tutorial does not assume prior knowledge of Haskell. It assumes, however, good general programming skills and basic experience with functional programming.

    Takeaway bullet points
    • Learn the power of dependent types.
    • Learn the fundamental ideas of type-driven development.
    • Learn how to use types as a guideline for designing APIs.

    Preparations

    Please install the Idris compiler on your machine. The current version is 1.3.2. More information can be found on the Idris homepage:

    https://www.idris-lang.org/

    It is beneficial to install an editor plugin for Idris. There are (at least) plugins for Atom, Vim and Emacs.

    Please make sure your setup works before coming to the tutorial, otherwise we won't have enough time discussing the features of Idris. Please contact the instructor should you have problems with the installation or the setup.

  4. in Tutorials B

    Einführung in Haskell (Erika Bor)

    Haskell ist eine stark typisierte Programmiersprache. Typen helfen den Programmierenden, Werte und Funktionen richtig einzusetzen. So werden Fehler im Programmcode zur Compile-Zeit erkannt und treten nicht erst zur Laufzeit in Erscheinung.

    Dieses Tutorial kann ohne jegliche Vorkenntnisse in Haskell und funktionaler Programmierung besucht werden.

    Angefangen bei “Hello, world!” tasten wir uns Schritt für Schritt zu zusammengesetzten Daten, Listen, Rekursionen und Funktionen höherer Ordnung vor. Dabei liegt der Schwerpunkt darin, Erfahrungen, die mir beim Einstieg geholfen haben, mit den TeilnehmerInnen zu teilen.

  5. in Talks B

    Effizient arbeiten mit Architecture Decision Records (ADR) (Johannes Dienst)

    Dokumentation gehört oft nicht zu den Lieblingsaufgaben im Softwareentwicklungsalltag. Das resultiert in vielen Fällen daraus, dass nicht klar ist, warum etwas dokumentiert werden sollte. Der in der Praxis gelebte Ansatz einen Dokumentationsort, zum Beispiel in Form eines Wikis, ist zum Scheitern verurteilt. Entweder es wird kaum dokumentiert oder zu viel und es wird schwer Informationen zu finden, die man sucht.

    Ein leichtgewichtiger Ansatz ist arc42, bei dem je nach Bedarf die vorgegebenen Unterpunkte ausgefüllt werden. Dort werden im Unterpunkt neun Entwurfsentscheidungen dokumentiert, also genau die Entscheidungen, die die Softwarearchitektur entscheidend prägen. Die Auswirkungen von nicht dokumentierten Entscheidungen gehen von immer wiederkehrenden Diskussionen, bis hin zu fehlerhaften Folgeentscheidungen die das Projekt zum Scheitern bringen können. Doch wie können viele Entscheidungen effizient und nachvollziehbar dokumentiert werden?

    In diesem Vortrag wird ein kompaktes Format namens Architecture Decision Records (ADR) vorgestellt und gezeigt, wie sie effizient eingesetzt werden können. Neben Kleinigkeiten wie der Titelvergabe für eine ADR wird ein Lösungsvorschlag aufgezeigt, um bei einer großen Sammlung von Entwurfsentscheidungen (>50) nicht den Überblick zu verlieren. Dabei kommt der Docs-As-Code Ansatz mit AsciiDoc und JBake zum Einsatz, mit dem die technische Architektur in einer Microsite gerendert wird. Durch Tagging und eine effiziente Suche, wird die Dokumentation nicht nur lebendig, sondern zum täglichen Arbeitsmittel.

  6. 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.

  7. Coffee break

    A break for coffee, tea, and mingling.

    For those attending the tutorials "Introduction to Idris" or "Einführung in Haskell", the break starts at 11:50.

  8. 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.

  9. in Talks B

    Opening Doors to Open Source (Jigyasa Grover)

    According to a recent survey by Github, only 4 % of open source participants & ideators are women and/or non-binary.

    This might be due to the fact that women especially find it intimidating to get started with contributing to open source. The talk will answer questions, throwing light on the issues that women usually have. It aims at introducing the audience to the world of FOSS and elaborate the vast range of opportunities ranging from coding to documentation, design, outreach and research. The talk aspires to inspire budding girl developers and showcase women who’ve made significant contributions to technology.

  10. in Tutorials B

    Graphen@Problemlösen (Holger Tiemeyer)

    Systemausprägungen und Anforderungen können multidimensionalen Ausprägungen unterliegen: Zigtausende Confluence-Seiten, endlos lange JIRA-Boards, hunderte Microservices, Cloud-Umgebungen etc. Der Einstieg in solche ein Projekt oder solch eine Domäne stellt uns als Softwareentwickler oder -architekt oft vor enorme Herausforderungen: Wir müssen diese Domänen schnell erfassen, um Lösungen für anfallende Anforderungen und Aufgaben zu finden. Oft genug stehen wir vor der Frage: Wie gehe ich jetzt an das Problem heran? Wo ist der Schlüssel zur richtigen Lösung? Dabei gibt es eine einfache Möglichkeit der Abstraktion: Graphen – ein miteinander durch Pointer (Zeiger) verbundenes Informationsgeflecht. Diese Pointer sind eine Basisgeste des Menschen und stellen das am stärksten ausgeprägten Visualisierungs-Tool dar. Mit minimalem Informationsverlust lassen sich hiermit die besten Lösungswege für ein Problem finden.

    In diesem Tutorial wollen wir Lösungen anhand graphenbasierter Modellierung erproben: Wie können wir sie effektiv einsetzen? Wie können wir mit ihnen Problemlösungsbarrieren überwinden und anhand von effektiver Informationsvisualisierung unsere Problemdomänen erklären und erfassen?

  11. in Tutorials A

    ReasonML and React (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.

    With the language comes a redefinition of the popular React-Framework: ReasonReact. ReasonReact finally realizes the original vision, its creator had for React - a fully functional driven frontend framework! The framework comes already equipped with hooks and reducers. It also provides a type safe way to build components in a JSX-like syntax - without the need to overspecify, thanks to Reason's excellent type inference.

    You will learn how to write Reason & ReasonReact code, which projects are worth using it and even when you should rather prefer alternatives like TypeScript or Elm.

    In this workshop we will

    • take a look at the concepts of the ReasonML-language
    • model data with the algebraic type system
    • build a simple frontend application in ReasonReact
    • write unit-tests with bs-jest
  12. 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.

  13. in Talks B

    Integration und Migration von systemkritischen Legacy-Anwendungen (Christoph Ehlts & Marcus Deiters)

    Vor zwei Jahren sind wir mit einer PL/SQL-Anwendung aufgebrochen in die funktionale Welt. Auf dem bisherigen Weg Richtung Elixir/Erlang erlebten wir viele technische und organisatorische Überraschungen, viele erfreulich, einige nicht.

    Ein Erfahrungsbericht über …

    • die organisatorischen Hürden in der Umsetzung einer technischen Vision

    • die Migration und Integration von Legacy-Anwendungen in eine funktionale Umgebung.

    Die Hoffnung ist, Argumente zu liefern, um den üblichen Bedenken beim Wechsel in die funktionale Welt entgegenzutreten.

  14. Lunch break

    A break for lunch.

  15. in Talks B

    Leveraging Algebraic Data Types (Franz Thoma)

    In functional programming languages, Algebraic Data Types and Pattern Matching are ubiquitous, and they are a very powerful and expressive tool. Unfortunately, many mainstream languages, especially in the object-oriented spectrum, lack these features and resort to rather cumbersome subtyping and inheritance.

    But not all is lost! Leveraging an old GoF pattern together with Lambda syntax that by now has spread to most modern programming languages, we can emulate ADTs and pattern matching in virtually any programming language.

    Applications range from implementation of standard ADTs like Maybe, Tuples and Either over standard functional data structures like Linked Lists and Fingertrees, up to complex structures like ASTs or DSLs.

  16. 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.

  17. in Tutorials A

    Introduction to TLA+ (Annette Bieniusa)

    Concurrent and distributed programs are notoriously difficult to get right. Even tiny variations of algorithms like Peterson’s lock for mutual exclusion lead to significantly different behaviours and errors that are complex to locate.

    TLA+ is a high-level language for modelling such programs and specifying their behaviour in a rigorous way. In this tutorial, you will learn how to write concurrent and distributed algorithms in PlusCal, a pseudo-code like interface for TLA+, and how to specify correctness conditions using temporal logic. We will further apply the model-checker TLC and discuss typical pitfalls when working with TLA+.

  18. in Tutorials B

    Einführung in F# (Tim Digel)

    F# (F Sharp) ist eine von Microsoft entwickelte funktionale Programmiersprache im .NET-Universum. Die Syntax erinnert sehr stark an OCaml.

    In diesem Tutorial starten wir bei Null und sehen uns nach vielen einführenden Anweisungen zusammengesetzte Datentypen (Records, Listen, etc.), Typisierung, Namensräume, Einrückung, Tests und Abhängigkeiten an.

    Es wird kein Vorwissen vorausgesetzt. Grundideen funktionaler Programmierung sind hilfreich, aber nicht zwingend erforderlich.

    Vorbereitung

    Um möglichst praxisnah zu arbeiten werden wir einiges in Visual Studio unter Windows betrachten. Um plattformunabhängig allen Interessierten die Möglichkeit zu geben, mit zu programmieren, verwenden wir zu Beginn Visual Studio Code. Weiter benötigen wir die Dotnet-SDK (siehe z. B. für Ubuntu). Alternativ lässt sich das komplette Setup unter Linux non-invasiv mit Hilfe von Nix mit diesen Schritten herstellen:

    # Install Nix Package Manager, see https://nixos.org/nix/download.html
    # Nix is available for Linux &  MacOS
    # Create a playground
     mkdir -p ~/fsharp-tutorial && cd ~/fsharp-tutorial
    # This will download some nix packages and starts a sub shell
    # Unfortunately dotnet-sdk isn't available for MacOS
    NIXPKGS_ALLOW_UNFREE=1 nix-shell -p dotnet-sdk -p vscode -p fsharp
    
    # Create a new F#-project
    export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=true
    dotnet new console -lang F# -i MyProject
    
    # Start Visual Studio Code
    code .
    # Install Extension: Ionide-fsharp
    

    In Visual Studio Code benötigen wir dann noch die Erweiterung Ionide-fsharp.

  19. in Talks B

    Self-Documenting Computation (Olaf Klinke)

    Undoubtedly, the standard format of sharing computations in the business world is the spreadsheet. But this quickly becomes unwieldy when complex algorithms are involved or deeply structured data are more appropriate for the problem at hand. So how to present the inner workings of an algorithm in such a way that it may be part of an invoice, to be checked by accountants? We advertise an idea that is actually as old as spreadsheets and show how, building on top of some popular Haskell packages, one can obtain an embedded domain-specific language for self-documenting computations.

  20. 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.

  21. in Main Room

    Coffee break

    With a talk from our sponsor Platform.sh!

  22. 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.

  23. in Talks B

    Bringing experimentation to JavaScript (Yulia Startsev)

    What is the cost of changing an api? How can we measure it? JavaScript is one of the most widely used and run languages in the world. The committee behind the design of JavaScript, Technical Committee 39 of Ecma, has to keep in mind many potential use cases, and errors that might occur as the result of a design change. However we do not have a framework of how to do this. As a delegate, I felt that this was an area where the committee could benefit from. This talk will cover the work that is happening now to introduce such a framework of experimentation to our process, where we are and what kind of experiments we are currently running.

  24. in Tutorials A

    Control Your Effects in Haskell (Mike Sperber)

    Functional programming is all about not using effects. Particularly in Haskell. Well, it turns out we sometimes do want to program with effects. When that happens, we keep them under control. With monads. Right? Unfortunately, monads compose quite poorly in Haskell, and when they do, using them is often awkward. The result is that much Haskell code takes a dive into the IO monad when really it should not. This tutorial is if you’re still willing to fight this disturbing trend.

    Strangely enough, with monads in Haskell past their 25th anniversary, this problem is only lately getting the attention it deserves. As a result, we have a handful of patterns and a quickly growing collection of effects libraries. Should you jump on one of those bandwagons or plod on with trusty old monad transformers? This tutorial will help you out!

  25. in Tutorials B

    Ganz praktisch: Probabilistische Funktionen (Christoph Schmalhofer)

    Zufallsprozesse sind überall, zum Beispiel: Aktienkurse, Antwortzeiten, Luftverschmutzung. Probabilistische Funktionen können Zufallsprozesse lernen, simulieren und Vorhersagen versuchen.

    Ein wenig Theorie
    • Universal (Higher Order) Probabilistic Programming
    • Stochastische Prozesse sind Probabilistische Funktionen
    • "A Convenient Category for Higher-Order Probability Theory"
    Intuition Gaußprozesse
    • einfach, gutartig, vielseitig
    • Anwendungen ohne Ende: Optimierung, Robotik, Geowissenschaften, ...
    • viele Einzeiler, viele Plots
    Fallstudie: Interpolation Mauna Loa CO2-Daten
    • Julia GaussianProcesses.jl
    • Kovarianzfunktions-Zoo
    Tinkering around
    • Analyse einfacher Datasets
    • probabilistische Funktionen selbst gebaut (Closures + Currying)
  26. in Talks B

    Engineering Principles of a highly effective team (Steve Robinson-Burns)

    So you know how to write code. You know how to work as an individual. But… how about as a team? When a team works well together, they can best fulfil the business function, while meeting personal emotional needs.

    In the past few years, at five companies, I’ve experienced a lot of different ways of working. Finally, at Previse, I was part of a team that solved problems together effectively. Sounds simple, but it had taken them a combined 80+ years of expertise to get there!

    The engineering team at Previse identified a methodology that guided their collaboration. Every day they engaged in the process of evolving it and embodying continuous learning.

    This talk is about better ways of working together. It’s worth accounting for how you’re just a bunch of emotional mortals. Identify your team’s unique characteristics, and get everyone on board.

  27. 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.