Ledgers - When would you even

I delivered this talk at SAP Inside Track Berlin in September 2018. The audience was mostly enterprise developers, almost all of them specifically working with SAP as a platform.

Given how many companies I’ve seen flirting with the idea of distributed ledgers, I thought it would be useful to give people an idea of which cases I see as being a good fit for them, to give them a leg up the next time it enters the discussion.



Slides at Speakerdeck.

Remember the rubber hose

I delivered Remember The Rubber Hose, a talk on privacy and distributed applications, at DappCon Berlin 2018. Skipping the introduction and going straight to the beef…



Slides at Speakerdeck.

Stories we tell ourselves

Last week I had the privilege to speak at infiniTIFF Summit, a part of the Transylvanian Film Festival dealing with technology, storytelling and experimental narratives.

I wrote Stories We Tell Ourselves for the summit. Below is a slightly longer version of the talk I gave.

Slides at speakerdeck.

It's about the curry

I got invited to speak at Monkigras 2018, a superb conference on software, technology and craft. This year’s theme was “Sustaining Craft”. I wrote and delivered It’s about the curry - you’ll find a (close enough) transcript below.



Slides at Speakerdeck.

Learning Through Mentoring

On Wednesday, April 26, I gave a talk at Webit 2017 in Sofia about mentoring and movies. The audio unfortunately came out like it was recorded through two tin cans connected by rusty barbed wire. I write these things as effectively a long speech, so my original notes should work as a transcript.

Update: Here’s the video from CodeMotion Berlin 2017.



Flexibility Through Immutability, part 2: How and When?

The second part of the original text for “Flexibility Through Immutability“.

The first part focused on the why of immutable data. On this part I’ll review what to do about if you’re working on an object-oriented language.

Flexibility Through Immutability, part 1: Why?

Here’s the original text for “Flexibility Through Immutability“, for those of you who prefer reading to watching a video.

It’s a bit of a long read, so I’ve divided it into two parts. The first one focuses on the motivations behind preferring immutable data, and the second one (which will go up on Wednesday) on how to go about it.

Flexibility Through Immutability

While functional programming has a lot of advantages, the more I worked on the paradigm, the more surprised I was at how much thinking in a functional manner made refactoring easier.

As happy as I am to sell people on Clojure, I realized that teams could benefit from adopting some functional programming ideas even on their current language. I decided to try a different approach, and gave a talk at the 2016 ITAKE Unconference in Bucharest, elaborating on the benefits of immutable data. I wanted to focus on how the functional paradigm has a value in-and-of-itself. A secondary goal was to provide some tips that teams who can’t yet pull away from C# or Java can put into effect to help.

You’ll find my screen recording, as well as the slides, below.

The Clojure learning curve

I love Clojure.

Once you have tried it and enjoyed its advantages, you just don’t want to go back. But those same qualities that make you love it can make it easy to forget that, for someone who’s first encountering it, Clojure can be a threatening, scary area far outside their comfort zone.

A few weeks ago I gave a talk at the Bucharest Functional Programming Meet Up. The title was Clojure All The Way Down, since my initial plan was to focus on how to program web applications completely in Clojure (both the browser client and back end), and what it brings to the table.

Two things happened as I prepared the talk.