•  

BOB 2017 schedule

Friday 24th February 2017

  • Funktionale Programmierung mit Swift

    by Stefan Wehr

    Apples inzwischen nicht mehr ganz so neue Programmiersprache Swift beinhaltet viele Elemente der funktionalen Programmierung. Wir schauen uns in diesem Tutorial genauer die funktionalen Elemente von Swift an und bringen sie zur praktischen Anwendung. Die Teilnehmer benötigen einen Mac mit Version 8.1 von Xcode.

    At 10:05am to 11:35am, Friday 24th February

  • Introductory Haskell

    by Matthias Fischmann

    Haskell is an elegant and fascinating language that has made purely functional programming practical. This tutorial aims at giving you a sense of direction in the Haskell eco system. We will explain and motivate key language concepts and introduce tools and development techniques as we need them for our examples.

    We will start by exploring basic syntax and the Haskell type system in an interactive Haskell environment. The need to write (slightly) larger programs will naturally lead us to the Haskell module system. We will show how to use cabal and the hackage library database to install packages and create our own.

    Key language concepts are hard to pick and will depend on the interests of the audience. Some candidates are algebraic data types and pattern matching, polymorphic functions, type classes, monads, GHC language extensions, or programming with typed holes.

    Presentation language will be English, but we are happy to discuss your questions in German.

    At 10:05am to 11:35am, Friday 24th February

  • The Future of Front-end Development: A comparison

    by Alexander T

    This talk will give a practical insight into front-end web development programming technologies based on my personal and professional experience. In detail we will compare up- and downsides of development with JavaScript, TypeScript, PureScript, Elm and GHCJS evaluating tooling, productivity, language design and possible architectures.

    At 10:15am to 11:00am, Friday 24th February

  • Und wer testet die Tests? - Mutationstesten mit PIT

    by Johannes Dienst

    Eine Testabdeckung von 50-80% ermöglicht es eine Codebasis wartbar zu halten. Refaktorisierungen sind dadurch sicherer durchführbar. Doch diese Sicherheit ist trügerisch. Denn wer garantiert, dass die Tests das richtige Testen? An dieser Stelle tritt eine “alte” Technik auf den Plan: Das Mutationstesten. Bereits 1971 vorgeschlagen, gewinnt es heute mit leistungsfähigen Multicore-Prozessoren immer mehr an Bedeutung. Der Vortrag zeigt die Leistungsfähigkeit dieser Technik am Beispiel der ausgereiften Bibliothek PIT. Mit dieser wurden Tests aus einem realen Projekt überprüft und deren Qualität erheblich gesteigert.

    At 10:15am to 11:00am, Friday 24th February

  • Introduction to Web Programming in PureScript

    by Michael Karg

    PureScript is a language for functional programming in the browser designed for low adoption barriers. It looks very much like somebody took static types and explicit effects out of Haskell and imposed them on javascript. And in fact, this is how Purescript was born.

    In the short 90 minutes we have, I will cover the basics of PureScript for those who are not familiar with functional programming, and then walk you through a small web app with purescript-halogen, a UI library that adheres to the Functional Reactive Programming (FRP) design. I hope to have time to demonstrate how purescript comfortably integrates with any existing JavaScript context, which makes it a great tool for incremental adoption.

    At 11:45am to 1:15pm, Friday 24th February

  • Mehr Konsistenz für replizierte Daten!

    by Annette Bieniusa

    Beim Programmieren von verteilten System müssen Entwickler sich einer ganzen Reihe von Herausforderungen stellen. Ein der schwierigsten Herausforderungen besteht darin Daten konsistent zu halten, wenn diese von mehreren Prozessen nebenläufig zugreifbar und modifizierbar sind.

    Entwickler haben dabei typischerweise zwei Möglichkeiten:

    Die Updates werden mit Hilfe einer Metrik (z.B. Zeitpunkt der Updates) total geordnet. Bei diesem nicht-deterministischen Verfahren können allerdings Daten verlorengehen.

    Alle Updates werden gespeichert und die Konfliktauflösung wird an den App-Entwickler bzw. Nutzer delegiert. Diese ad-hoc Konfliktauflösung ist in der Regel aber nicht-trivial und ist oft fehlerhaft implementiert.

    Konflikt-freie replizierte Datentypen (CRDTs) bieten eine alternative Lösung. Diese Datentypen implementieren eine deterministische Konfliktauflösung, beispielsweise über eine dedizierte Merge-Funktion. Dies gestattet dem Entwickler sich auf die Datenmodellierung zu konzentrieren.

    In meinem Tutorial gebe ich eine Einführung in eine Open-Source Bibliothek für CRDTs in Erlang. Die Semantik der verschiedenen Datentypen und ihrer Strategien zur Konfliktauflösung werden wir anhand von Beispielen diskutieren und dabei verstehen, wie CRDTs in einer verteilten Anwendung zum Einsatz kommen können.

    At 11:45am to 1:15pm, Friday 24th February

  • Shell-Scripting mit Haskell

    by Franz Thoma

    Scripting in Hochsprachen bringt gegenüber blankem Shell-Scripting viele Vorteile wie Modularität oder Verwendung von existierenden Libraries. Vor allem dynamisch typisierte Sprachen wie Python sind dafür sehr beliebt. Statisch typisierte Sprachen erhöhen zudem die Wartbarkeit durch das Abfangen von Fehlern zur Compile-Zeit, sind aber oft weniger flexibel einzusetzen.

    Für Haskell gibt es turtle, ein Framework von Gabriel Gonzalez zum Schreiben von Shell-Skripten. Standard-Befehle wie ls und cd werden emuliert oder an das Betriebssystem delegiert, Pipes bekommen dank do-Notation Steroide, und Kommandozeilenparameter werden deklarativ definiert und automatisch geparst – mit kostenloser Bash-Completion.

    At 11:45am to 12:30pm, Friday 24th February

  • Synergy of IoT and BPM

    by Yevgen Pikus

    Nowadays analyzing vast amount of sensor data in real-time for process optimization and event prediction has become a major task for a production line. Major questions focus on how to build a system to process multiple gigabyte data per second on various locations. In this presentation we focus at a BigData analytics platform which is built on top of the SMACK stack, it is an acronym for Spark, Mesos, Akka, Cassandra and Kafka. SMACK provides an ecosystem for handling high frequent low-level events and for the creation of high-level events to trigger business processes as a reaction to derived knowledge in a bimodal IoT architecture. To go into detail, we break down to a stream based approach, SMACK components and interaction between them. The central parts of the system (Spark Streams, Akka Streams, Akka Actors) will be revealed on concrete code snippets in Scala. Learning outcomes for attendees: better understanding of SMACK, benefits of a pure functional approach for building scalable platforms, experiences and best practices for working with SMACK, assets of bimodal architecture for combining IoT and BPM.

    At 11:45am to 12:30pm, Friday 24th February

  • Immutable Hash Maps: Plenty of room at the bottom

    by Peter Schuck and Cliff Rodgers

    The Hash Array Mapped Trie (HAMT) has become the standard implementation for Immutable Hash Maps. However there is still room for big improvements with this central data structure.

    The Compressed Hash Array Mapped Prefix-tree (CHAMP) is a modification of the Hash Array Mapped Trie that performs the hat trick of

    • Speeding up iteration and equality checking by 100% or more
    • Lowers memory overhead
    • Reduces the lines of code needed by 33%, along with making the implementation much easier to understand

    At 12:35pm to 1:20pm, Friday 24th February

  • Performance and Safety: an Example of using Liquid Haskell in the Real World

    by Philipp Kant

    No one should ever be forced to choose between performant and robust software. Yet sometimes, when we have to squeeze every bit of performance from our code, we are tempted to leave abstractions behind and go down to the level of bare pointer arithmetic. Thus, we reduce all overhead for the sake of improving speed, at the price of risking segmentation faults and worse.

    Using the example of the Store serialisation library, we show how to get the best of both worlds, by using Liquid Haskell. Liquid Haskell is an extension of Haskell’s Type system that allows annotating types with refinement predicates. For example, this allows us to encode, in the type system, that some pointer points to a region in memory of a certain size. Thus, the absence of pointer overflows can be encoded in the types of our functions, and be proven by Liquid Haskell. This is superior to performing bounds checks in several ways:

    • There is no runtime overhead.
    • Since the correctness is statically proven, we do not need to handle errors at runtime.
    • Writing down the involved invariances in Liquid Haskell helps to get a precise understanding of our code and possible sources of errors.

    The talk aims to be practical, showing in detail how to use Liquid Haskell to prove the correctness of assumptions about your code.

    At 12:35pm to 1:20pm, Friday 24th February

  • Bayadera: Bayes + Clojure + GPU

    by Dragan Djuric

    Have you ever seen hierarchical probabilistic models computed in milliseconds? Now it is possible, on a low-cost desktop machine, from a dynamic and interactive REPL environment in Clojure. This talk presents Bayadera, an opinionated Bayesian statistical library backed by a high-speed massively parallel MCMC engine that runs on the GPU. Bayadera has been designed with programmers in mind; it is optimized not only for dynamic, interactive model-building and experimentation, but also to provide fast performance in production. There is even more; Bayadera has been written in Clojure, which is a pragmatic modern Lisp dialect that runs on Java Virtual Machine, and plays well with the Java ecosystem. The talk will introduce interactive development in Clojure, an infrastructure for high-performance numerical computing provided by Uncomplicate libraries, and give a walk-through of real model building and fitting from one of the later chapters of the Doing Bayesian Data Analysis.

    At 2:15pm to 3:00pm, Friday 24th February

  • React.js and Redux

    by Nicole Rauch

    The increased computing power of browsers allows to move more and more of the application logic into the frontend. These so-called single-page-apps appear to be much snappier because all calculations happen on the user’s computer, and there is little to no transfer of data over the network most of the time. Over the past few years, a number of frontend frameworks appeared, and some of them already disappeared again. React.js, a rather younger proponent, impresses because it is lightweight and it focuses on the UI. Technically, it allows to describe the web application in a declarative way, without relying on the omnipresent events and listeners. Redux handles the application state and the user actions and is a perfect match for React.js.

    In this workshop, the participants create a single-page-app with React.js and Redux in small steps.

    At 2:15pm to 3:45pm, Friday 24th February

  • Tausend auf einen Streich: Einführung in QuickCheck

    by Lars Hupel

    Das man als Entwickler nicht nur Produktions-Code sondern auch Tests zu schreiben hat, ist mittlerweile ein alter Hut. Trotzdem ist es für viele eine lästige und monotone Arbeit. Außerdem ist es noch lange nicht garantiert, dass Unit-Tests auch wirklich alle Grenz- und Nicht-Grenz-Fälle abdecken. Ein moderner Ansatz ist eigenschaftsbasiertes Testen, bei dem eine abstrakte Bedingung spezifiziert wird, die dann vom Test-Framework automatisch überprüft wird. In diesem Vortrag wird es um die Bibliothek „QuickCheck“ und einige weiterführende Techniken gehen, mit denen man – mit vertretbarem Aufwand – Tests deutlich zuverlässiger machen kann.

    At 2:15pm to 3:45pm, Friday 24th February

  • Writing a native Mac GUI application in Haskell

    by Nikolas Mayr

    Haskell is a superb language for implementing Mac applications with native GUI. Yet this approach is rarely taken by developers.

    This talk examines the development of the JSON Class Generator, a full-fledged NSDocument based Mac application, written partly in Objective-C and largely in Haskell. It reveals the application’s architecture and illuminates the main design decisions and alternative implementations. The presentation explains, how the two distinct language runtimes co-exist and communicate with each other inside a single binary and how a functional reactive user interface was constructed and tested on top of this layer. It concludes by stating under which circumstances the benefit of combining two languages does compensate the seemingly higher effort.

    At 2:15pm to 3:00pm, Friday 24th February

  • Functional package management with GNU Guix for developers and power users

    by Ricardo Wurmus

    Package management seems to quickly become a thing of the past as developers and distributions increasingly accept bundling and binary imaging as a solution to the problems caused by traditional packaging and deployment efforts. We claim that the level of packages is still the most appropriate level of abstraction and demonstrate how functional package management fixes the defects of traditional package management. We introduce GNU Guix as an implementation of a functional package manager and showcase features that are especially useful for developing software and for maintaining heterogeneous software environments.

    The effects of expressing packages in a DSL embedded in the general purpose language GNU Guile (one of the key differences to Nix) will be demonstrated by interacting with packages on the REPL and showing tools that use Guix as a Scheme library.

    At 3:05pm to 3:50pm, Friday 24th February

  • Write one program, get two (or three, or many)

    by Kosmikus

    Many programming problems are data conversion problems. Data has to be converted between two different formats: for example, between a representation as a Haskell datatype and JSON. Implementing this conversion consists of two parts: in the case of the example, one that converts from Haskell to JSON, and one that parses JSON into Haskell. By using generic programming techniques, one can often get both directions for free. We write just the datatype definition, and let a library derive the conversions completely automatically, together with a guarantee that the conversions are compatible with each other. But sometimes, we cannot use the generic definition, for example, because the required JSON representation is slightly unusual. In such a situation, we would still like to write only one mapping from Haskell to JSON rather than two, and construct the program in such a way that a roundtrip property between our conversion functions is essentially guaranteed. In this talk, I will show how this can be done for the example of Haskell and JSON and discuss in how far this can be turned into a more general programming technique that is applicable to a wide variety of situations (and programming languages).

    At 3:05pm to 3:50pm, Friday 24th February

  • An introduction to Servant

    by Kosmikus

    Servant is a domain-specific language embedded in Haskell that allows the specification of web APIs as Haskell types.

    Once such an API has been specified, it can be used to drive the implementation of various components, such as a server handling requests according to the API, or also a client that sends requests according to the API, or also documentation of the API itself.

    In all these cases, most of the program is derived automatically from the shape of API, and the developer only has to fill in the remaining parts, such as the handlers for a server, or the endpoint descriptions for documentation. And everything happens in a type-safe way.

    Servant therefore shows nicely that types can do more for us than just catch errors; they can instead help us write parts of our programs automatically for us, and guide us in their construction.

    In this tutorial, we will incrementally develop a small web backend application in Haskell using Servant, and look a little bit at how it works internally and can be extended with new functionality.

    The language of the tutorial is English.

    Servant makes use of various Haskell language extensions for type-level programming. These will be introduced as we go. However, some basic familiarity with Haskell or at least another statically typed functional programming language is going to be helpful.

    At 4:20pm to 5:50pm, Friday 24th February

  • Der Widerspenstigen Zähmung - Funktionale Programmierung in einer kleinen Firma

    by raichoo

    Funktionale Programmierung spielt in der Softwareentwicklungslandschaft immer noch eine Randrolle. Besonders in Deutschland gilt FP weiterhin als exotisch oder erweckt den Eindruck eines akademischen Spielzeugs. Dieser Vortrag ist ein Erfahrungsbericht und beschreibt aus der Sicht eines FP-Enthusiasten wie Haskell als eine valide Option für die tägliche Entwicklung in einer kleinen Firma etabliert wurde, welche Probleme dabei bewältigt werden mussten, sowie die Wahl von Libraries, Werkzeugen und “best practices”.

    At 4:20pm to 5:05pm, Friday 24th February

  • Einführung in Agda

    by Peter Thiemann

    Viele Programmierer führen nur ungern Beweise: Agda verwendet das Curry-Howard-Prinzip “Beweise sind Programme”, so dass es ausreicht ein typkorrektes Programm zu schreiben um zu zeigen, dass ein Programm seine Spezifikation erfüllt.

    Agda ist eine funktionale Programmiersprache mit abhängigen Typen und gleichzeitig ein interaktives Beweissystem. Das mächtige Typsystem erlaubt, auch substanzielle Eigenschaften direkt ins Programm zu schreiben.

    Nach einer Einführung in die funktionale Programmierung mit Typen und das Curry-Howard-Prinzip führen wir anhand von Beispielen die wichtigsten Features von Agda vor. Zum Abschluss beleuchten wir einige Anwendungen von Agda und geben Hinweise auf Informationsquellen zum Thema.

    At 4:20pm to 5:50pm, Friday 24th February

  • Graph databases - why and how

    by Szymon Warda

    From graph theory through the history of computing and how it affected database design, to why relational databases aren’t about relations. Next, a look at how diverse the current graph database market is and what obvious and not so obvious problems are solved by graphs. We will see how to launder money, suggest products, give answers to NLP tasks, build a knowledge base, balance a game economy and model mixed concept domains. A short introduction to Neo4j’s query language, Cypher, will show the main concepts of querying graph data. Then, by use of the same datasets in both relational and graph databases will compare syntactic clarity and database performance.

    At 4:20pm to 4:50pm, Friday 24th February

  • Privacy-first data structures on SAFE

    by Benjamin Kampmann

    Blockchain technology like Bitcoin popularised the concept of decentralised consensus. Together with the rise of peer-to-peer technologies, it becomes possible to entirely decouple data-ownership from its physical storage and reorganise information in a privacy-sensitive manner. SAFE is a decentralised communication and storage network with a local-group-consensus mechanism to ensure consistency. But without central servers how do you organise user-generated content – like comments on a blog?

    In this talk, we will explore the privacy-first data structures employed on SAFE, how you can use cryptography to provide access control on the data layer directly and thus rethink the idea of “central storage in the cloud”. Finally, we will take a short look into the important role functional programming will play in these networks in the future

    At 5:10pm to 5:55pm, Friday 24th February

  • The Hidden Nature of Data

    by Martin Kühl

    Encapsulation is a pillar of object-oriented programming, but how important is it in the context of functional programming? Is it worth clinging to, or should we stay away? This talk will examine the tradeoffs of encapsulating internal representations versus exposing the “nature” of our data.

    Programming with immutable values and algebraic data types usually makes hiding fields behind accessors unnecessary. On the other hand, hiding functions and types is a crucial technique control our API, encouraging correct usage and affording the flexibility to change it.

    In this session we will explore constraints that encourage encapsulation, discuss how it affects our types, their algebras, and their algorithmic properties, and learn about alternatives and their benefits and drawbacks.

    At 5:10pm to 5:55pm, Friday 24th February

Schedule incomplete?

Add a new session

Filter by Day