Skip to main content
BOB 2019

Logo of BOB 2019 BOB 2019

22nd March 2019

Berlin, Germany

Part of the BOB series
Lohmann & Birkner »

Talks #2

Sessions in this room

  1. in Talks #2

    EventSourcing All Over the Place

    By now EventSourcing is an established alternative to handle and store data in the backend. But did you realize that frontend architecture patterns like Flux/Redux basically also work in an event-sourced way? Unfortunately, in these patterns the event store is inaccessible, though. With some simple tricks we can make use of it and establish proper EventSourcing in the frontend as well. Moreover, these events can also be used to synchronize changes in frontend and backend without the need to divert from the EventSourcing pattern.

    This talk demonstrates how this technique works in general and how it was used in a real project.

  2. in Talks #2

    Checking Musical Correctness

    Music theorists have a questionable history of taking tendencies observed in European musics and deploying them as prescriptive rulesets. Fortunately, musicians break these rules whenever it suits them. In fact, cognitive science suggests that rulebreaking and manipulating audience expectations is fundamental to how music is able to provoke emotion. But in the universe of algorithmic music, we can, if we choose, use software correctness techniques like schemas and types to enforce musical rules. This gives rise to a dilemma. If we make illegal states unrepresentable, do we make innovative states unimaginable? This talk will attempt to resolve the dilemma using a practical reconciliation between Paul Hudak’s Haskell school of expression and David Huron’s psychological theory of expectations.

  3. in Talks #2

    Programmation en Logique

    Prolog is one of the most underrated programming languages around; possibly because of its strange syntax and the unusual paradigm. But it is a very nice special-purpose programming language. In this talk, I would like to introduce Prolog’s programming model, showcase some programming domains in which Prolog allows for very concise, elegant programs, and finally describe how it can also be used as a general-purpose tool.

  4. in Talks #2

    The Way of APL

    While early Von Neumann style programming gave way to Structured Imperative Programming, which in turn evolved into Functional and OOP programming paradigms that are currently very popular, another programming paradigm was maturing and developing: the array programming paradigm. This deeply misunderstood programming model receives equal parts derision and wonder, while remaining largely under-appreciated and under-utilized, despite numerous success stories as well as research and evidence to back up its sometimes miraculous claims. Modern computer designs and our need for better methods for dealing with the needs of rigor, correctness, performance, and scale warrants a deeper look into the subtleties that are embedded in the quintessential array programming language, APL.

  5. in Talks #2

    Analyzing Programs with SMT Solvers

    Have you ever wanted to prove non-trivial properties of your programs automatically? It’s actually practical with modern SMT solvers like Z3! I’ll walk you through how we can compile a program to an SMT formula and how we can use that formula to do bounded verification—checking assertions in our code statically or comparing a program against an executable specification. This technique is tricky in general purpose programming, but works wonders for domain-specific languages.

  6. in Talks #2

    Modern SQL

    Purely relational SQL has been abandoned in 1999. Since then, SQL has got many non-relational features for problems that are hard to solve with relational algebra. Today, SQL is Turing complete, can process graphs, has semantic understanding of XML and JSON, is able to automatically keep historic versions, can analyze time series using regular expressions and much more.

    This presentation demonstrates what modern SQL can do for you. It compares two different approaches to common problems: a purely relational one and the modern SQL approach. You will see that modern SQL databases are the Swiss Army Knives of persistence which allow up to react quickly when requirements change.

    In this session, developers and software architects of all levels gain a better understanding where SQL is today so that they are able to make more educated decisions. A lot has happened since SQL-92!

  7. in Talks #2

    Emotional Programming

    We model the real world, we program behaviour, we build intelligent machines, we are creators of universes. Coders are mostly antisocial nerds. However, if you’re a non-nerd involved in a software project, you will need to deal with the code produced by the nerds, even if it’s as incomprehensible as their pick-up lines. Those incomprehensible programs, and the resulting mismatch between our minds, the world, and the code - are a key vulnerability of our universe. (And, if we continue to flood the real universe with IoT devices, that universe, too.) To address this vulnerability, people need to communicate - coders and non-coders, both about the code and through the code. We need code that is welcoming, empathic, charming, and beautiful. Software craftsmanship, functional programming, and domain-driven design all can help, but by themselves they are not enough. Mainusch and Sperber are cretins of communication: They can’t even decide which of them is the nerd. Sperber talks monads, Mainusch unsuccessfully waits for them to click. Mainusch talks ideas, Sperber puts code on slides. But in this talk, they will connect - and if they can connect, so can the people in your project. We walk a software lifecycle from back to front, giving examples for communication beauties and beasts alike, show how to overcome the inevitable communication breakdowns and find inspiration and beauty in your project.